Arcgis Tampa

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

Annotations already mark the operation as read-only and idempotent; the description adds valuable context about cost implications ('BYO key — you pay Anthropic directly'), the default model selection, and the per-model return shape. No contradiction exists. It does not mention potential latency or third-party data handling, but with annotations present, the disclosure is strong.

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, front-loaded with the action and output, and every sentence provides distinct value: purpose/scope, model configuration and cost, return format, and use cases. No fluff or redundancy.

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 explicitly lists the per-model return fields ({score, confidence, signals, raw_response}) and a combined view. It covers purpose, model options, cost, helpers like context disambiguation, and typical use cases. The information is complete enough for an agent to select, invoke, 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?

Schema coverage is 100% and each parameter already has a meaningful description. The tool description reinforces defaults (e.g., 'Default model is Workers AI Llama-3.3-70b') and clarifies the relationship between _apiKey and models, but it doesn't materially expand beyond the schema. This meets the baseline for well-documented parameters.

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 'Probe one or more LLMs for what they know about a business / brand / product / topic and score visibility (0-100) per model', giving a specific verb, resource, and measurable output. It clearly distinguishes this tool from sibling tools by focusing on per-model AI visibility scoring. The return structure and use cases are also immediately clear.

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

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

Provides clear context: default model is free, optional Anthropic probing requires BYO key, and the tool is 'Useful for AI-marketing audits, pre-launch brand checks, competitive monitoring.' It stops short of explicitly naming when not to use this tool or listing alternative sibling tools, but the guidance is sufficient for an agent to decide when to invoke it.

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 establish this is safe/read-only, and the description adds meaningful behavioral context: it routes and aggregates across thousands of verified sources, fills arguments automatically, and returns stable citation URIs. It is consistent with the annotations and expands on what an agent should expect.

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

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

The description is dense but organized: an initial directive, a clear explanation of routing behavior, explicit usage trigger phrases, examples, and escalation guidance all in one place. It is longer than average, but most sections earn their place because they directly guide tool selection.

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 high-complexity tool with no output schema, this description covers the important context: candidate domains, criteria for use, fallback/alternative tools, source scope, and the expected return format (structured answer with citation URIs). An agent should be able to select and invoke this tool confidently.

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

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

Schema coverage is 100%, and the schema already documents that all six parameters are aliases for a natural-language question. The description enriches this by providing concrete examples of acceptable queries and by emphasizing the broad type of question the tool is meant to handle.

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 phrase: routes a question to one of 5,564 tools and returns a structured answer with citation URIs. It clearly distinguishes itself from siblings like ask_pipeworx_grounded and deep_research by positioning itself 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 extensive when-to-use guidance: it explicitly says to prefer this over web search for factual questions, lists concrete example phrasings, and names the alternatives for special cases (ask_pipeworx_grounded for grounded answers, 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?

Annotations already declare readOnlyHint true, idempotentHint true, and destructiveHint false, so the safety profile is well covered. The description adds behavioral context beyond annotations: it explains beta status, that results are compared against the stable router to decide merges, and that it is a full working router rather than a fallback. This enriches the agent's understanding of experimental 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 concise yet packed with essential information: beta status, current state (no active candidate), equivalence to stable version, usage guidance, and evaluation purpose. Every sentence contributes value, and the structure is logical and front-loaded with the most important info (beta version). 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?

The tool has no output schema, but the description notes 'same response shape' as the stable tool, which gives a baseline for expected returns. It also explains the experimental edge and fallback behavior, covering the tool's role in the system. It lacks detail on what happens when a candidate is active, but the current state is accurately described. Overall, it is complete for an experimental router.

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

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

Schema description coverage is 100% — all six parameters are aliases for 'question' and are fully described in the schema. The description adds no extra parameter guidance, but it appropriately states 'same arguments' as the stable tool, so the agent can rely on the existing parameter semantics. Given high schema coverage, a baseline 3 is appropriate.

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

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

The description clearly states it's a beta version of ask_pipeworx, a universal router with a large toolset, and explicitly distinguishes it from the stable sibling by noting experimental routing improvements. The verb 'ask' and resource 'pipeworx' are clear, and it differentiates by its beta status and current match to the stable version.

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

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

The description provides clear context on when to use: 'Use it exactly like ask_pipeworx when you want the newest routing.' It also explains that currently no candidate is active, so it matches the stable version, which implicitly advises that for stable usage one might prefer the stable sibling. It lacks an explicit 'do not use when' clause but gives sufficient situational 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?

Goes well beyond annotations by disclosing the extraction-only behavior, the exact success/refusal return shapes including refusal_reason enum values, and the extra LLM call cost. Annotations (readOnly, openWorld, idempotent) are consistent with the description; 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 dense but well-structured: it opens with the core value proposition, then explains the mechanism, return contract, refusal reasons, use cases, and cost tradeoff. Every sentence carries necessary information with no redundancy.

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 specifies the success response fields and all refusal reasons, making the tool's behavior completely predictable. It also contextualizes the extra cost and relationship to ask_pipeworx, covering the full complexity of a routing 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?

Schema covers all 6 parameters as aliases for 'question' at 100% coverage, providing the baseline. The description adds semantic value by explaining that the question is used to 'pick the right tool... fills arguments,' clarifying that the parameter drives internal routing rather than being a mere string, which elevates it above pure 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 a specific purpose: a hallucination-resistant answer mode that extracts answers only from tool results, returning evidence and explicit refusals. It distinguishes itself from sibling ask_pipeworx by emphasizing grounded, high-stakes use and the extra LLM call cost.

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

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

Explicit when-to-use guidance is provided: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' with concrete examples. It also gives a when-not-to-use alternative: 'prefer ask_pipeworx for casual lookups' due to 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 goes far beyond the annotations by detailing resolution matching confidence, low-confidence short-circuit behavior, closed-market handling, illiquid spread warnings, and cancellation-rule edge cases. It also warns that resolutions are blocking and explains the parent_event extractor. There is no contradiction with the readOnly/openWorld/idempotent hints.

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

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

The description is quite long and densely packed, but it uses clear section headings (CLASSIFIERS, FAN-OUT EXAMPLES, RESPONSE SHAPES) which aid scanning. While some sentences are redundant (e.g., explanation of the closed-market path), the content is largely necessary for such a behavior-rich tool, earning a 4 rather than a 2.

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 thoroughly explains the response shapes, including result.market fields, analysis fields, evidence keys, resolver contract, parent event, news fallback fields, and resolution-rule risk. It even covers edge cases like illiquid spreads and cancellation rules, providing complete contextual coverage 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 description coverage is 100%, and the schema itself already provides detailed explanations for market, depth, and include_raw, including examples and default values. The main description adds some fan-out examples for depth but does not substantially add new parameter semantics, so baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose with a specific verb ('Research a Polymarket bet') and resource ('Pipeworx data'), followed by explicit use cases ('should I bet on X', 'what does the data say about Y'). It distinguishes itself from sibling tools like polymarket_edges by focusing on fetching data for a single specified market rather than scanning for 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?

Provides explicit use contexts ('Use for should I bet on X...') and a taxonomy of bet classifiers. However, it does not explicitly mention alternative sibling tools or state when not to use this tool, so it lacks full exclusions—though the context is clear enough for an agent to infer appropriate usage.

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

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

Annotations already indicate a safe read-only idempotent operation; description adds data source specifics (SEC EDGAR/XBRL, FAERS), handling of fiscal years, sorting by primary metric, and citation URIs, which are valuable behavioral details not present in 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?

While slightly long, the description is front-loaded with trigger phrases and packs dense, useful information into a structured format. Each clause adds value, though some redundancy exists between 'head to head' and 'side-by-side' phrasing.

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

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

Despite no output schema, the description explains return content (paired data + citation URIs) and sorting behavior, covering key outcomes. It also addresses edge cases like fiscal year alignment, making it thorough for the tool's complexity.

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 both parameters with descriptions, and the description enriches them by explaining what each enum value retrieves (company vs drug) and the expected value format (tickers/CIKs vs drug names), adding functional 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 explicitly states 'side-by-side comparison of 2–5 companies or drugs in ONE parallel call' with a clear verb and resource. It distinguishes from single-entity lookups by noting it replaces sequential lookups, and its trigger phrases make the tool's scope obvious.

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 trigger phrases and explicit preference: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It defines the appropriate context (comparing 2-5 entities) and differentiates by entity type via type parameter.

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?

Even with annotations already declaring readOnly, idempotent, and non-destructive behavior, the description adds substantial behavioral detail: parallel facet decomposition, findings packet contents, gaps[] for unanswered facets, contradictions[], hop fields, resolvable citation_uri, semantic excerpting, and expected latency. There is no contradiction with 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?

Although lengthy, the description is dense and topically organized: prerequisites and alternatives first, then core behavior, then return characteristics, then latency. Every sentence carries operational value, and there is no repetition or filler.

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

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

For a complex research tool with no output schema, the description is remarkably complete. It covers return format elements, gap behavior, contradiction detection, citation resolvability, excerpting strategy, depth semantics, auth requirements, and runtime expectations, leaving no major operational gap.

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

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

Schema coverage for both parameters is 100%, so the description does not need to compensate. It reinforces the depth parameter's meaning and confirms the question parameter can be broad, but it does not add significant parameter-level detail beyond what the schema already provides.

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

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

The description clearly states the tool's function: grounded multi-source research across structured data sources in one call, decomposing questions into facets and routing to tools in parallel. It explicitly distinguishes itself from open-web search and 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 gives explicit when-to-use guidance: it is best for broad/multi-part structured-data questions, while single lookups and breaking/current-news queries should go to ask_pipeworx. It also states the signed-in prerequisite and points to ask_pipeworx as a fallback on free tiers.

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 provide readOnly, idempotent, and non-destructive hints. The description adds meaningful return behavior: it returns top-N tools with names, descriptions, and full schemas, and explicitly notes that results are directly callable with no second lookup. This goes beyond the safety profile to explain operational 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 front-loaded with purpose, then usage context, then return details, and finally a strategic call-to-action. The long list of domains is somewhat verbose but serves as useful scope information for an agent. Each sentence earns its place, though a slight trim of the domain list could improve 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?

Given no output schema, the description adequately explains return values (top-N tools with schemas and examples) and states the tool's role as a first-step discovery mechanism. Combined with complete input schema and annotations, the description leaves no critical gaps for an agent to decide when and how to invoke 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?

The input schema covers 100% of parameters with clear descriptions, including aliases and the limit field. The description reinforces the concept of 'top-N' and natural-language queries but adds no significant semantic detail beyond what the schema already communicates. With full schema coverage, the baseline of 3 applies.

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

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

The description opens with 'Find tools by describing the data or task,' which clearly identifies this as a meta-tool for discovering other tools. It lists specific domains and distinguishes itself from sibling tools by positioning itself as the entry point ('Call this FIRST'), making its unique role 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 when to use it: 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This gives clear timing and intent, effectively guiding selection among siblings without needing to name 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?

Beyond the annotations (readOnly, openWorld, idempotent), the description discloses several behavioral traits: it 'fans out across SEC EDGAR, XBRL, USPTO, news, GLEIF,' mentions the USPTO API sunset and 'soft-fails until reactivated,' and notes the GDELT→GNews fallback. It also details the exact output fields, including URIs and sorting. This adds significant behavioral context that annotations alone do not provide.

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

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

The description is long but every sentence carries critical information: query examples, use-case preference, fan-out sources, return fields, parameter formats, and limitations. It is front-loaded with the most important instruction ('ALWAYS PREFER...') and structured with clear lists. No filler or redundant wording.

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

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

The tool has no output schema, so the description fully compensates by enumerating all return components (cik, company_name, recent_filings with URIs, fundamentals with field details, patents, news, LEI). It also covers edge cases (USPTO sunset, name unsupported) and parameter constraints, making it complete for effective selection and invocation.

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

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

The schema already covers both parameters with descriptions (enum for type, format note for value). The description adds concrete examples ('AAPL', '0000320193') and reiterates the name unsupported constraint, which is helpful. It does not need to compensate for schema gaps, but it enhances usability with illustrative values and fallback hints. A slight deduction for some redundancy with schema text.

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 concrete example queries ('Tell me about X', 'research Acme') and clearly states the tool's function: 'full cross-source profile of a US public company in ONE parallel call.' It distinguishes itself from siblings by explicitly preferring it over chaining single-pack SEC/XBRL/news lookups and refers to resolve_entity for name-only inputs. The verb 'profile' plus resource 'US public company' 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?

Usage guidance is explicit: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also provides an exclusion: 'names not supported (use resolve_entity first if you only have a name).' This clearly tells the agent when to use this tool and when to delegate to an alternative.

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 destructiveHint=true and idempotentHint=true, so the description doesn't need to restate them. It adds context about what kind of data is affected ('previously stored memory') and why to use it (clearing stale or sensitive data), which goes beyond the structured 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?

Two sentences; the first is a clear direct action, the second provides usage guidance and sibling references. No filler, front-loaded, efficiently communicates all essential information.

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

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

For a one-parameter tool with no output schema and informative annotations, the description is fully sufficient. It covers what, when, and how to use it, and contextualizes it within the memory toolset.

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

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

Schema coverage is 100% and the schema already describes the single parameter 'key' as 'Memory key to delete'. The description adds no extra detail about the parameter beyond what the schema provides, so 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 states 'Delete a previously stored memory by key' – a specific verb, resource, and mechanism. It distinguishes clearly from sibling tools like remember (store) and recall (retrieve).

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

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

Explicitly states when to use: 'when context is stale, the task is done, or you want to clear sensitive data'. Also hints at alternatives by telling the agent to pair with remember and recall, which are the complementary 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 the sequence of operations (fetches page, extracts title/description/key links, emits markdown) and the output format. Annotations already mark it as read-only and idempotent, and the description adds the network fetch behavior without contradicting those hints.

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

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

The description is three sentences long, with the action and purpose immediately front-loaded. Every sentence serves a purpose: purpose, process, and use cases, with no redundant or promotional filler.

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

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

The tool is simple with only two parameters and a text output, and the description covers the operation, the output format, and practical applications. The schema and annotations cover the remaining details, making this complete for a tool of this complexity.

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?

Both parameters are fully documented in the schema (url and max_links) with clear descriptions, so the description does not need to add parameter details. The description adds general context about the URL being any site, but no extra syntax or default values 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 generates a production-ready llms.txt file for any URL, with specific mention of the extraction and output format. It distinguishes itself from sibling tools by focusing solely on llms.txt generation, unlike visibility checks or deep research 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 'Useful for' section explicitly lists three concrete scenarios (client indexing, drafting llms.txt, auditing a competitor), providing clear context on when to use it. However, it does not name any alternative tools or explicitly state when not to use it, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral detail by listing what the tool returns (fields, geometry type, count, capabilities), which goes beyond the generic safety profile. It doesn't 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 a single, well-structured sentence that front-loads the verb and includes a complete list of return items. Every word carries meaning; there is no fluff or repetition.

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

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

The tool has only one parameter, no output schema, and strong annotations. The description fully explains what the tool does and returns (fields, geometry type, count, capabilities), making it adequate for an agent to select and invoke correctly. No additional context is needed.

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

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

The schema covers 100% of parameters (url) with a description and example. The tool description merely references 'by url' without adding new semantic detail, so the baseline of 3 is appropriate. No additional parameter explanation is needed 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 uses a specific verb ('Get') and names the resource ('ArcGIS Feature/Map Service layer's schema'), then enumerates exactly what is returned: fields (name + type), geometry type, total record count, and capabilities. This clearly distinguishes it from sibling tools like query_layer, which would fetch features rather than schema.

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

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

The description makes the usage context clear: call this tool when you need a layer's schema/metadata by URL. It doesn't explicitly mention alternatives or exclusions, but the specificity of 'schema' implies a distinct use case from data-returning tools. A more explicit 'use this instead of query_layer when you need metadata' would earn 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 already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by listing the exact fields returned (id, type, params, created_at, last_fired_at, fire_count) and specifying 'caller's' scope. It doesn't add rate limits or pagination, but given the annotations, this is sufficient.

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

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

The description is two sentences, front-loaded with the core purpose, then return fields and usage. Every sentence earns its place with no repetition or filler. It is highly efficient 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?

This is a simple list tool with one optional parameter, no output schema, and robust annotations. The description covers the return format and usage context, which is complete for the tool's complexity. No gaps remain that would hinder an agent from selecting and invoking the tool correctly.

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

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

The schema has 100% coverage for the single parameter include_inactive, including a clear description. The tool description does not mention this parameter, but the schema fully explains it, so the baseline of 3 is appropriate. The description adds no extra semantics beyond what the schema already provides.

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

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

The description clearly states the verb 'List' and the resource 'the caller's active subscriptions', which is specific and unambiguous. It also distinguishes the tool from siblings like subscribe and unsubscribe by focusing on listing existing 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 explicitly says 'Use this to review what you're monitoring before adding more or to find an id to cancel', providing clear when-to-use guidance relative to the sibling tools subscribe and unsubscribe. It implies using this before those mutation tools, which is strong guidance.

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

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

With all annotations false, the description fully carries the burden and exceeds it. It discloses rate limiting (5 per identifier per day), zero quota cost, daily digest/roadmap impact, the no-account claim_token flow, and that follow-up returns status and resolution details. There is 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 long but every sentence earns its place: purpose, usage, exclusions, token mechanics, rate limit, and quota impact. It is logically ordered and front-loaded with a clear purpose statement, though slightly dense as a single block.

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 fully prepares the agent: it explains return token handling, follow-up calls, rate limits, scope boundaries, and what happens to the feedback. It is complete for a nuanced feedback tool with optional parameters.

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 operational value: 'Describe the issue in terms of Pipeworx tools/packs—don't paste the end-user's prompt' clarifies message and context, and the claim_token usage example shows the exact follow-up call shape.

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 action—'Tell the Pipeworx team something is broken, missing, or needs to exist'—and clearly defines the resource (Pipeworx tools/packs). It distinguishes itself from sibling research/query tools by focusing on reporting feedback rather than retrieving data.

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

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

It explicitly lists when to use the tool ('Use when a tool returns wrong/stale data...') and when not to ('if the tool came from a different MCP server... file it with that server instead'). It even provides a disambiguation rule for identifying Pipeworx tools, giving the agent unambiguous selection criteria.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description adds valuable behavioral details: it is self-aggregating from CF analytics-engine, contains no PII, returns only (pack, tool, count), and is cached 5min-1h depending on window. This enriches the agent's understanding of data source, privacy, output granularity, and performance characteristics.

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 well-structured, starting with an engaging hook, then stating the return value, followed by use cases and additional details. Each section adds value, but it is slightly longer than necessary. The 'Useful for' list could be condensed, but overall it is efficient and front-loaded.

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

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

For a tool with one optional parameter and no output schema, the description is comprehensive. It specifies what is returned (top tools, top packs, total call volume), the data structure (pack, tool, count), the windows, the caching behavior, and privacy characteristics. This is sufficient for an agent to invoke the tool correctly and interpret basic 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?

The schema already provides a complete description of the single 'window' parameter, including enum values and semantics ('Shorter windows surface what's hot right now; longer windows show steady-state demand'). The description only briefly mentions the windows without adding new meaning, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: it returns top tools, top packs, and total call volume over recent windows. The verb 'Returns' is specific, the resource ('top tools, top packs, and total call volume') is precise, and it distinguishes this from siblings like discover_tools by focusing on current usage trends ('What other AI agents are calling on Pipeworx right now').

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: discovering hot data sources, confirming canonical tools, and aligning with agent needs. These serve as clear context for when to use the tool. However, it does not explicitly mention when not to use it or name alternative tools, so it falls short of a 5.

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

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

Despite annotations already indicating read-only/non-destructive behavior, the description adds substantial behavioral context: it discloses the Jaccard threshold, placeholder filtering, null-arbitrage signal, and the fill-check logic with a warning not to trade when realizable edge ≤ 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 long but structured with labeled sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK) and front-loaded with the essential usage. Every sentence adds unique information; there is no redundancy or filler.

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

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

Even though there is no output schema, the description enumerates the response fields for both modes and details edge cases (skipped_low_similarity, placeholders_filtered, thin_legs). The tool's complexity is fully addressed, and it cross-references a sibling tool for sizing.

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?

Both event and topic are described in the schema with full coverage, and the description adds deeper semantics: it provides concrete example slugs/questions, explains the child-market walk and comparator behavior, and clarifies the no-argument default. This far exceeds 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 opening sentence specifies the verb ('Find arbitrage opportunities') and resource ('Polymarket') and distinguishes the approach (monotonicity violations + partition-sum checks). It further differentiates from siblings by describing specific modes (trending_scan, event, topic) and referencing polymarket_fill_risk.

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 instructs when to call with no args, with an event slug, or with a topic, and recommends event for specific markets. It also tells users to use polymarket_fill_risk for custom sizing, providing a clear alternative.

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, but the description goes far beyond: it discloses the internal model families, response segmentation, diagnostics for empty segments, the 24h-move warning, caching behavior ('Cached 1h at the KV level keyed on all knobs'), and the Fed signal caveat. This is rich behavioral context that annotations cannot convey.

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 and dense but well-structured with all-caps section markers and dash-separated details. Every sentence carries technical substance, and the front-loaded purpose ensures quick understanding. It loses a point for being somewhat overwhelming as a wall of text, though the complexity likely justifies the length.

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

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

With no output schema, the description thoroughly explains the response structure: by_segment, fed_candidates/fed_note, and _diagnostics with funnel counters and filter_skips. It also details the fields on each opportunity (edge_pp_net, kelly_fraction, market.liquidity, etc.) and the reasoning for Fed bet exclusion, making the tool fully comprehensible.

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 provides 100% parameter descriptions, so the baseline is 3. The tool description adds some context by grouping knobs (e.g., 'TRADEABLE-EDGE KNOBS') but largely repeats schema content. For example, min_partition_leg_kelly is already thoroughly explained in the schema, so the description contributes marginal additional meaning.

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

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

The description opens with a specific verb+resource: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It clearly differentiates from sibling tools like polymarket_arbitrage by detailing its aggregation of five model families into three segments, establishing a unique 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?

The description includes a clear use case: "Built for 'what should I bet on today' — agents discover opportunities without paging hundreds of markets." It also gives practical tuning guidance for knobs (e.g., max_spread_pp=2 for tight books). However, it does not explicitly name alternatives or state when not to use this tool, so it misses the top score.

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 (readOnly, idempotent, non-destructive), the description discloses detailed behavioral traits: response structure (tracked[], expired[], snapshot_dates[]), data lineage (snapshots written on cache-miss, gaps mean no scan), computation methodology (daily closes of edge_pp_net, net of slippage, not intraday), and limitations (60-day TTL, start time). It also clarifies the sign convention (negative = SELL YES), which is critical for interpreting results.

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 well-structured with labeled sections (Args, RESPONSE, LIMITS) and is front-loaded with the core purpose. Every sentence carries distinct information—purpose, parameter defaults, response fields, and limitations—without redundancy. Although lengthy, the complexity of the tool justifies each 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?

With no output schema, the description takes on the full burden of explaining return values, and it does so in detail (tracked[], expired[], snapshot_dates[] with their semantics). It also covers edge cases (missing data, TTL limits) and the edge sign convention, making the tool self-sufficient for an agent to invoke and interpret 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% (both parameters have descriptions in the input schema), so the baseline is 3. The description restates defaults and adds the concept of 'snapshot family' for window, but does not add significant new semantics. It also omits the lower clamp (2) present in the schema, and the schema already enumerates options for window.

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 purpose—'edge persistence and decay telemetry built from daily polymarket_edges snapshots'—and immediately answers a concrete question: 'how long has this edge existed and is it shrinking?' This distinguishes it from siblings like polymarket_edges (which likely provides current edges) by focusing on historical time-series and decay analysis.

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 use context: it explains the tool's value in differentiating a fresh wide edge from a 3-week-old wide edge, implying it should be used to assess edge age/decay before trading. However, it does not explicitly name alternatives (e.g., polymarket_edges for current snapshots) or state 'use this instead of X', so the guidance is implicit rather than explicit.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds rich context beyond this: two distinct modes (single-market vs basket), default behaviors (side default buy_yes, size_usd default 1000), and the risk of partial fills producing unhedged positions. It also names the returned verdicts and per-leg detail fields.

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 packed with essential information: mode selection, parameter interpretation, output fields, verdict options, and risk warnings. It is structured with clear SINGLE-MARKET and BASKET sections. Every sentence adds value, though the length is at the upper limit for quick reading.

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 complex two-mode tool with no output schema, the description is remarkably complete. It explains runtime requirements (one of market or event), mode-specific behavior, all key return values (theoretical_sum, realizable_sum, capture_ratio, thick/thin legs, forced_directional_risk), and the primary use case. The risk explanation about partial fills is critical contextual information that the schema and annotations cannot convey.

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 four parameters. The description adds valuable semantic distinctions: size_usd is 'max spend' on buys vs 'target proceeds' on sells in single-market mode, and 'settlement notional' in basket mode. It also clarifies that side defaults auto based on partition sum in basket mode. This goes 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 specific verb and resource: 'Realizable-vs-theoretical edge check against live CLOB order-book depth.' It clearly distinguishes this from sibling tools like polymarket_arbitrage and polymarket_edges by focusing on fill/execution risk rather than signal detection.

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

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

Explicit when-to-use guidance is given: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It also explains why (theoretical overround on thin books is not capturable) and warns about partial basket fills converting arbs into unhedged directional positions.

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 (readOnly, idempotent), the description discloses detailed behavior: compatibility_warning conditions, matched_pairs logic, temporal_alignment, skipped_cross_type/subtype semantics, and the fact that it auto-fetches events for topic shortcuts. This is comprehensive and goes well beyond what annotations provide.

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

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

The description is detailed and well-structured, with clear sections for modes, response, and safety fields. It is somewhat long but each sentence adds necessary information; it could be tightened slightly in the caveat section without losing 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?

With no output schema, the description explains the response format, including leg-by-leg prices, spread top_spreads_pp, compatibility_warning, temporal_alignment, and skipped_cross_type counters. This makes the tool's output predictable and complete for an agent to 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 covers all three parameters with descriptions, so the baseline is 3. The description adds the semantics of the two modes and clarifies that explicit parameters override the topic-mapped side, giving additional meaning about parameter interaction that the schema alone doesn't convey.

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

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

The description opens with a specific verb+resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It clearly distinguishes the tool from siblings like polymarket_arbitrage by focusing on cross-venue comparison between two named platforms, and it states the exact function (calculating spread).

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

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

It explains two usage modes (topic shortcuts vs explicit ticker/slug) and provides caveats that pre-mapped topics may return compatibility_warning and 'pre-mapped ≠ tradeable'. However, it doesn't explicitly name alternative sibling tools for when to choose this over another, so the 'alternatives' component is implied rather than explicit.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description adds useful behavioral context: it returns attribute rows and geometry, and supports SQL-like where clauses. It also discloses the parameterized nature of the query. No contradictions found.

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

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

The description is two sentences, front-loaded with the core purpose, and lists key parameters in a compact, scannable way. The tip about sampling is practical and not redundant. Every sentence earns its place with 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?

The description covers the main purpose, the return value (rows and geometry), and key parameter options. It does not explain default limit or pagination details, but those are in the schema. With no output schema, the return-type mention is valuable. It is complete enough for a straightforward query tool, though it could hint at error handling or access requirements.

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 all 6 parameters have descriptions in the input schema. The description reiterates some parameter usage (e.g., 'comma-separated out_fields') and adds a usage tip for sampling, but does not add significant meaning beyond what the schema already defines. This is the baseline for high schema coverage.

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

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

The description clearly states the primary action: 'Query an ArcGIS Feature Service / Map Service layer by its url' – a specific verb and resource. It also ties the URL source to 'search_datasets', distinguishing it as a downstream step from dataset discovery and from sibling tools like layer_info or search_within.

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 mentions 'from search_datasets', implying a workflow: first find a dataset, then query it. It also gives a practical sampling tip with where='1=1' and out_fields='*'. However, it does not explicitly state when NOT to use the tool or name alternative tools for different query types (e.g., search_within for spatial filters).

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, and the description adds meaningful context: scoping to the caller's identifier and the dual behavior (retrieve by key or list all). This goes beyond what annotations alone convey, though it does not detail edge cases like missing keys or return format.

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

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

Three sentences, all substantive: the first states the core function, the second gives use case and examples, the third explains scoping and pairing with siblings. No filler or redundancy.

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 a simple optional parameter, no output schema, and strong annotations, the description covers purpose, usage, and scoping fully. It also situates the tool within a clear memory workflow (remember/recall/forget), making it complete for an agent to select and invoke 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%: the single 'key' parameter is fully described ('Memory key to retrieve (omit to list all keys)'). The description echoes this and adds context about the memory being saved via 'remember', but does not add new parameter-level details beyond the schema.

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

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

The description uses a specific verb ('retrieve') and resource ('value previously saved via remember'), and clearly distinguishes itself from siblings by stating it also lists all saved keys. It differentiates from 'remember' (save) and 'forget' (delete), leaving no ambiguity about its role.

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 to look up context the agent stored earlier' and why ('without re-deriving it from scratch'). It also names the complementary tools ('Pair with remember to save, forget to delete'), providing clear context versus 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:true, yet the description says setting mark_read:true flags returned events read so the next call only shows newer ones, implying a state-changing side effect on the persisted feed. This directly contradicts the read-only annotation, even though the description does add useful field and polling context.

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

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

Three sentences with a clear front-loaded purpose; every sentence carries functional information (return fields, filtering, side-effect, polling, alternative endpoint) with no filler.

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

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

Despite no output schema, the description discloses the key return fields (source, citation_uri, raw payload) and covers filtering, mark_read behavior, polling suitability, and an alternate access URL. This is complete for a read-oriented 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?

The input schema already documents all five parameters at 100% coverage, so the baseline is 3. The description adds value by giving a concrete type example ('sec_8k'), clarifying since as an ISO timestamp relative to fired_at, and explaining the consequence of mark_read:true.

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 ('Pull fired events from your subscription feed') and immediately clarifies the resource is a persisted feed of evaluator-written alerts. It distinguishes itself from siblings like list_subscriptions by focusing on fired alert events with fields and filters.

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

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

It explains filtering by type/since and the mark_read polling idiom, and explicitly mentions an alternative HTTP endpoint for scripts/dashboards. It doesn't explicitly state when not to use this tool versus other subscription tools, but the context 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 it read-only/idempotent/non-destructive. The description goes further by disclosing the parallel fan-out architecture, source-specific fallbacks (GDELT→GNews on rate-limit/5xx), the PatentsView sunset soft-failure, accepted since formats, and the structured return shape. 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?

While dense, every part serves a purpose: examples, sources, fallbacks, formats, return contract, and alternative. It is structured with clear subjects and front-loaded, making it accessible despite 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?

For a multi-source aggregator with no output schema, the description covers sources, failure modes, date syntax, return structure, and an alternative tool. It is essentially self-contained for an agent to decide and invoke 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 covers all three params with descriptions. The description adds value by mapping `since` to the SEC filings window, `value` to ticker/CIK, and suggesting typical monitoring values ('30d' or '1m'), which goes beyond the schema's field-level docs.

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

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

The description opens with natural-language examples and explicitly frames the tool as a 'change feed for a company in the last N days/weeks/months in ONE parallel call.' It names the fan-out sources and distinguishes itself from entity_profile, making purpose unmistakable.

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

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

It provides clear usage signals with example queries ('What's new with X') and explicitly instructs to use entity_profile for static profiles. It also documents fallback behavior for GDELT→GNews, giving operational context.

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

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

Beyond annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false), the description adds behavioral context: scoping by identifier and the 24-hour retention policy for anonymous sessions. It doesn't contradict annotations and provides meaningful extra information, though it doesn't detail overwrite semantics or 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 two sentences that efficiently cover purpose, usage trigger, storage model, persistence behavior, and companion tools. Every clause earns its place without redundancy, and it maintains clear structure from 'what' to 'when' to 'how'.

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

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

For a simple two-parameter write tool with no output schema, the description is complete. It explains the core action, use cases, scoping, persistence duration, and how to retrieve or delete the data, providing sufficient context for correct invocation.

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

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

Schema description coverage is 100% for both parameters, with clear examples for key and value. The description reinforces their key-value nature but adds no new syntax or format details beyond what the schema already provides, so 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 uses a specific verb+resource ('Save data') and clearly states the tool's function: storing key-value pairs for reuse across conversations or sessions. It also differentiates from siblings by explicitly pairing with recall and forget, situating it within a memory management workflow.

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

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

The description gives clear when-to-use guidance ('Use when you discover something worth carrying forward') and provides explicit alternatives by naming recall for retrieval and forget for deletion. It also distinguishes persistent memory for authenticated users versus 24-hour retention for anonymous sessions, which helps decide when this tool is appropriate.

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 annotations (readOnly, idempotent, non-destructive), the description adds rich behavioral detail: internal cascading across multiple endpoints, graceful degradation if GLEIF/OpenFIGI are unavailable, source labelling per identifier, explicit 'unresolved' field, and that ISINs resolve to legal entities via GLEIF. 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 lengthy due to the tool's complexity (two entity types, multiple identifier sources), but it is well-structured: begins with query examples, then explains each type. Every sentence adds value, though some internal detail (e.g., LEI/FIGI enrichment) could be streamlined without losing 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?

Given no output schema, the description does a good job explaining return content (identifiers with sources, unresolved list) and covers both entity types thoroughly. It could be more explicit about the exact output structure (e.g., JSON format), but for the complexity, it provides sufficient completeness.

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

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

Schema coverage is 100%, but the description adds substantial meaning: for company, it clarifies accepted inputs (ticker, CIK, ISIN, company name) and how ISIN resolution works; for drug, it specifies brand/generic name. This enriches 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 resolves names to canonical identifiers, gives concrete query examples ('ticker for...', 'find CIK for...'), and lists supported types (company, drug). It clearly distinguishes from sibling lookup tools by positioning itself as the first step when an ID is needed.

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 guidance on when to use: 'Use FIRST whenever you have a name but need an ID.' It does not explicitly state when not to use or name alternatives, but the context of sibling tools (e.g., entity_profile) makes the usage boundary inferable.

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, and non-destructive behavior. The description adds that the tool probes each entity via ai_visibility_check, ranks by score, and returns a ranked list with score, confidence, and signal density—information beyond the annotations. It does not disclose potential external API dependencies or rate limits, but those are partially covered by the _apiKey parameter schema.

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

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

The description is three sentences: a clear action, the mechanism, and a use case, followed by return format. Every sentence earns its place, with no redundancy or 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?

Despite lacking an output schema, the description explicitly states the return format (ranked list with score, confidence, signal density). It also covers purpose, underlying mechanism, and an example use case. The required entities parameter is self-explanatory, making the description complete for this tool's complexity.

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 parameter meaning is fully documented in the schema. The description does not add parameter-specific semantics beyond what the schema already states; it only reiterates the general concept of comparing entities. Baseline 3 is appropriate.

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

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

The description uses the verb 'Compare' with a specific resource ('AI visibility across multiple entities side-by-side'), and clearly distinguishes itself from the sibling ai_visibility_check by stating it probes each entity with that tool and ranks results. The concrete use case ('does Claude know about us as well as our competitors?') further 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?

The description gives a clear context ('competitive AI-marketing audits') and implies multi-entity comparison, but it does not explicitly state when to avoid it or name alternative tools for single-entity checks. It does mention it wraps ai_visibility_check, which hints at the underlying alternative, but lacks a direct 'use X instead' directive.

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, but the description adds substantial non-obvious behavior: partial failure degradation, specific timeout timing (5-30s for first bundlephobia measurement), the existence of a sources_failed field, and the NPM-only restriction in v1. 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 dense but exceptionally well-organized: purpose first, then detailed data sources, then usage triggers, then constraints and failure behavior. Every sentence contributes unique information with no redundancy. It's longer than average, but the complexity of the tool justifies 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?

There is no output schema, so the description fully accounts for the return value by listing the summary block fields (is_latest, license, published_at, etc.), per-advisory detail, links, and alternative versions. It also covers error handling and timing, making it complete for an agent to invoke 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?

Schema has 100% coverage for both parameters (package and version). The description adds value with concrete examples ('@types/node', '18.3.1') and clarifies the default version behavior. This exceeds the baseline of 3 for high schema coverage, though it doesn't add syntax or format details beyond the schema.

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

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

The description opens with a specific verb and resource: 'Composite “should I add this npm package to my project” check' and explicitly names the data sources (deps.dev, bundlephobia) and what it returns. It clearly distinguishes this tool from siblings by focusing on npm package evaluation and noting that other ecosystems fall under a different tool (deps.dev:version).

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 trigger phrases ('is X safe / popular / small', 'what does adding lodash cost me') and an explicit exclusion: 'PyPI / Maven / Cargo / Go fall under deps.dev:version directly.' This tells the agent exactly when to use this tool and when to look elsewhere.

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 readOnly, idempotent, openWorld, and non-destructive behavior. The description adds valuable beyond-annotation detail: the exact return fields (name, summary, record_count, owner/org, Feature Service url) and a concrete integration step, especially useful since no output schema exists.

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

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

Two sentences deliver purpose, scope, return shape, and downstream usage with zero redundancy. The verb+resource is front-loaded, and every clause earns its place.

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

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

For a search tool with no output schema, the description adequately covers return fields and integration. It could mention optional org_id behavior or empty/result-limit handling, but annotations and schema already fill most structural 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 description coverage is 100%, with clear descriptions for query, limit, and org_id. The description only says 'by keyword' and does not add new parameter-level meaning, so the baseline 3 is appropriate.

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

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

Description uses a specific verb ('Search') with a well-defined resource ('City of Tampa GIS open geospatial datasets') and gives representative content categories. It also distinguishes itself from siblings by explicitly noting it returns Feature Service URLs for use with query_layer/layer_info.

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 contextual guidance: the agent is told to search by keyword and can pass the returned URL to query_layer/layer_info, positioning this as the discovery stage. It lacks explicit when-not-to-use or alternative comparisons (e.g., search_within), 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?

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description discloses technical behaviors: BGE-base-en embeddings, cosine similarity over 500-char overlapping windows, a 200K character cap with truncation flagging, and the return of character offsets and similarity scores. This gives the agent a clear model of how results are produced and its limitations.

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 dense sentences with no filler. It front-loads the primary purpose, then gives a use case and technical specifics. Every sentence earns its place, making it both concise and informative.

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 simple read-only nature and rich schema/annotations, the description covers everything needed: what it does, when to use it, how it behaves (embeddings, windows, cap), what it returns (passages with offsets and scores), and its relationship to a sibling tool. No critical details are missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds minor context (e.g., 'a SEC 10-K body' as example text, 'top-N passages' referencing limit), but the schema already defines each parameter's meaning and constraints. No significant new parameter-level semantics are provided.

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 specific verb and resource: 'Semantic search INSIDE a fetched record.' It distinguishes itself from siblings by explicitly mentioning 'Pairs with ask_pipeworx_grounded' and describing its unique role of searching within already-pulled text rather than fetching or grounding over whole documents.

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 context: 'Use when the record is too big to cram into the prompt' and names the alternative workflow 'fetch with the gateway, ground over the relevant passages instead of the whole document.' This clearly tells the agent when to choose this tool and how it complements ask_pipeworx_grounded.

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 far beyond the annotations by disclosing authentication requirements, the always-on feed behavior, delivery channel specifics, SMS caps, webhook signing secret, and auto-disablement after 10 failed webhook runs. It also notes that anonymous and BYO accounts cannot persist subscriptions. This rich behavioral detail materially helps the agent anticipate side effects and constraints.

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

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

The description is dense and front-loaded with the core action, then breaks down types and channels. It packs substantial detail into a single paragraph without fluff, though the length is somewhat high. The structure is logical, but the density could be slightly easier to parse with segmentation. Overall, it earns a high score for using every sentence meaningfully.

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 (nested objects, multiple subscription types, multiple delivery channels, no output schema), the description is remarkably complete. It covers prerequisites, return value (subscription id), delivery options, limits, and failure behavior. The absence of an output schema is compensated by explicit statements about what is returned, including the one-time webhook secret.

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

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

The schema covers all parameters with examples, and the description reinforces and extends this with concrete per-type configuration objects (e.g., sec_8k items, polymarket_edge topic, fred_series series_id). It also explains delivery semantics and requirements like phone verification and webhook HMAC signing. This exceeds the baseline by adding operational meaning beyond raw schema 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 opens with a specific verb and resource: 'Create a proactive monitoring subscription to a live-data event stream.' It clearly differentiates from sibling tools like list_subscriptions and unsubscribe by focusing on the creation action, and it lists the supported subscription types with concrete examples. This makes the tool's purpose 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 provides clear context on when to use the tool (to create subscriptions) and what prerequisites are needed (Pipeworx OAuth account, phone verification for SMS). It does not explicitly mention when not to use it or name alternatives, but the contrast with sibling list/unsubscribe tools is implied. This is strong but not fully explicit.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds useful context beyond that, such as returning examples drawn from the live catalog and including the exact tool + argument shape. It does not mention rate limits or auth, but those are not critical given the safe read-only nature. This is a solid disclosure above the annotation baseline.

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 the natural-language prompts, then states the purpose, return value, and usage. Every sentence carries useful information and there is no filler, but it is longer than strictly necessary. It earns a 4 for being well-structured and concise enough for the tool's importance.

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 is comprehensive for a read-only onboarding tool. It covers what the tool does, what it returns, how to invoke it (with and without arguments), and how it fits into the tool ecosystem (referencing meta-tools). No output schema exists, but the description adequately explains the return content. Given the low complexity and strong annotations, this is complete.

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

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

The input schema already documents the single optional 'topic' parameter with enumerated values and the 'omit for cross-category spread' behavior. The description mentions passing topic with examples ('finance', 'pharma', 'betting'), but these are already in the schema. Schema coverage is 100%, so the description adds marginal semantic value, baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose with a specific verb and resource: it is the 'onboarding entry point' that returns 'category-bucketed example questions' with the exact tool and argument shape. It distinguishes itself from siblings like discover_tools and ask_pipeworx by explicitly saying to use it FIRST when you don't know what Pipeworx can do.

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: 'Use this FIRST when you do not yet know what Pipeworx can do for you.' It also explains call variations (no arguments for full spread, topic parameter to focus) and references meta-tools for further learning. This clearly communicates usage context 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?

Beyond the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false), the description discloses ownership enforcement and that the row is deactivated rather than deleted, preserving historical events via recent_alerts. This is valuable behavioral context not present in 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?

Two sentences, front-loaded with the action, and every clause adds information: ownership, deactivation, and data availability. No fluff or redundancy.

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 cancellation tool with no output schema, the description covers the purpose, behavioral constraints, and data lifecycle implications. It is self-sufficient 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?

The schema already fully describes the single parameter (id, uuid returned by subscribe), so the description adds little parameter-specific meaning. The ownership note is tool-level, not parameter-level. With 100% schema coverage, baseline 3 is appropriate.

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

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

The description clearly states the action ('Cancel a subscription by id') and the resource (subscription), distinguishing it from siblings like 'subscribe' and 'list_subscriptions'. It also adds ownership scope and notes the difference from deletion via deactivation, which further clarifies its unique role.

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

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

The description implies when to use the tool (you have a subscription id) and provides context that you can only cancel your own subscriptions. It doesn't explicitly name alternatives or when-not-to-use, but the sibling list and param description ('returned by subscribe') fill that gap. The deactivation note also guides users expecting full deletion.

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 provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description goes far beyond this by enumerating the verdict types, explaining that could_not_verify means the check did not happen and must not be shown as evidence, and mentioning verification_error{stage,detail}. It also clarifies the difference between unsupported and could_not_verify. This is rich behavioral context that materially improves agent understanding.

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?

Although the description is long, it is front-loaded with purpose and examples, then flows through pipeline routing, verdicts, and important caller warnings. Every sentence adds value, and the structure is logical and efficient for a tool with two execution paths and six verdict types.

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 and error semantics. It lists all verdict types, describes the grounded vs. structured paths, mentions citation and reasoning, and carefully explains the could_not_verify vs. unsupported distinction. This is complete for an agent to know when to call and what to expect.

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

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

Schema coverage is 100%, and the schema already provides descriptions for both parameters. The description mentions 'exact percent-delta math' and tolerance overrides in prose, but it does not add new parameter semantics beyond what the schema already states. The baseline of 3 applies because the schema carries the semantic load.

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 natural-language example phrasings and clearly states the tool verifies factual claims against authoritative sources. It explicitly distinguishes company-financial claims (SEC EDGAR+XBRL fast path) from other claims (grounded pipeline), which separates it from sibling tools like ask_pipeworx or resolve_entity.

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

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

The description gives explicit guidance: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also clarifies the routing for financial vs. other claims and notes it replaces 4–6 sequential calls. However, it does not name direct sibling tools as alternatives or state when not to use it, so a 4 is appropriate.

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