Osrm

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds valuable behavioral details: free default model, BYO key for Anthropic with direct cost, return per-model data including 'raw_response' and 'signals'.

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 ~70 words, front-loaded with action and purpose, then details parameters and use cases. Every sentence adds value with zero 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 no output schema, the description explicitly lists return fields: per-model {score, confidence, signals, raw_response} + combined view. It also covers all 4 parameters, their defaults, and use cases. For a tool with 4 params and no nested objects, this is fully complete.

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

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

Schema description coverage is 100%. The description adds context beyond schema: default model is Workers AI Llama-3.3-70b (free), and explains _apiKey is needed for Anthropic. This helps an agent understand the parameter roles better.

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

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

The description clearly states the tool probes LLMs for visibility and scores it (0-100). It specifies verb 'probe' and 'score', resource 'LLMs' and 'visibility'. It distinguishes from siblings like 'entity_profile' or 'scan_competitor_ai_presence' by focusing on AI model knowledge scoring.

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 use cases: 'AI-marketing audits, pre-launch brand checks, competitive monitoring'. It lacks explicit alternatives or when-not-to-use, but context is clear. No mention of when to use other tools.

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

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

Beyond the read-only/idempotent annotations, the description discloses that the tool auto-routes, fills arguments, returns structured output with stable pipeworx:// URIs, and is a single fast call available on every tier. It could add failure-mode or latency caveats, but annotations already establish the non-destructive nature.

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

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

The description is front-loaded with the most important routing instruction and well-organized into scope, triggers, examples, and escalation path. It is longer than minimal and repeats the 'prefer over web search' idea a couple of times, so it is not quite the tightest possible.

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 states what the caller gets back ('structured answer with stable pipeworx:// citation URIs'), what question types are supported, and exactly when to use sibling tools. For a broad default router, nothing essential is missing.

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

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

Schema description coverage is 100%: all parameters are documented as aliases for 'question', so the schema does the heavy lifting. The description's examples reinforce natural-language usage but add no essential parameter mechanics beyond the schema.

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

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

The description clearly identifies a specific action and scope: it routes factual questions to the right one of thousands of sources, fills arguments, and returns structured answers with citation URIs. It also distinguishes itself from siblings by positioning as the default entry point and contrasting with ask_pipeworx_grounded and deep_research.

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 and actionable: it lists trigger phrasing ('what is', 'look up', 'get the latest'), provides concrete examples, states 'PREFER OVER WEB SEARCH' even when web search could answer, and gives exact step-up conditions for ask_pipeworx_grounded and deep_research.

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

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

Annotations already cover read-only, open-world, idempotent, and non-destructive behavior. The description adds valuable context beyond that: this is a live experimental router, candidates may be enabled at any time, none is currently active, and results are compared against the stable router. It also explicitly clarifies there is no fallback, making it a fully working router.

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

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

The description is compact and front-loaded with the most important facts: beta, identical router, candidate routing status, and usage guidance. A few phrases are slightly redundant ('Use it exactly like ask_pipeworx' after saying 'identical'), but overall every section contributes needed context.

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 universal router with no output schema and a large sibling set, the description is nearly complete: it covers what the tool does, current behavior, how to use it, experimental status, and lack of fallback. It adequately equips an agent to call it correctly, though it could briefly mention what kinds of questions are best suited to it.

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

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

Schema description coverage is 100%, with every parameter documented as an alias for the question field. The description only refers to 'same arguments' without adding semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, an identical universal router over the same 5,724 tools, with candidate routing improvements applied when under test. It distinguishes itself from the stable ask_pipeworx sibling by its experimental edge, while removing ambiguity about its current scope.

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

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

It gives explicit usage guidance: use it exactly like ask_pipeworx when you want the newest routing. It also explains the current state (no active candidate, so behavior matches ask_pipeworx exactly), though it does not explicitly state when to prefer the stable alternative instead.

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 readOnly, openWorld, idempotent, and non-destructive behavior, and the description adds substantial context: it discloses the refusal mechanism, the exact refusal reasons, a structured success response, strict grounding to the tool result, and the performance trade-off of an extra LLM call. 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 detailed but every sentence carries functional information: purpose, routing behavior, grounding guarantee, response shape, refusal reasons, use cases, and cost trade-off. It is front-loaded with the most decision-relevant characteristic and contains no filler.

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

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

There is no output schema, so the description properly carries the burden of explaining return values, which it does by specifying the success object and the full refusal object with enumerated reasons. It also covers usage context, relationship to ask_pipeworx, and when to prefer the alternative, making the tool fully actionable.

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% — every parameter, including five aliases, is documented in the input schema. The description adds no parameter-specific meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description opens with a specific purpose: 'Hallucination-resistant answer mode for high-stakes reads,' and clearly differentiates this tool from its sibling ask_pipeworx by explaining that identical routing is used but answers are extracted only from the tool result. The verb 'extracts' and resource scope make the tool's function 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?

Use is explicitly gated: use when answers will be quoted, cited, or acted on and facts must not be invented, with concrete examples such as financial verdicts and legal claims. It also states when not to use it, preferring ask_pipeworx for casual lookups, and warns of the extra LLM call cost.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds extensive behavioral details: resolver contract (market_match_confidence, alternatives), parent_event extractor, news fallback fields, safety blocking for low-confidence/closed/wide-spread matches, and resolution-rule risk parsing. All consistent 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 well-structured with labeled sections (RESPONSE SHAPES, RESOLVER CONTRACT, etc.). It front-loads the core purpose and use cases. While some details could be condensed, the structure justifies the length.

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

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

Given the tool's complexity (multiple fan-out types, response structures, safety checks, error states), the description covers all relevant aspects without requiring an output schema. It explains behavior for edge cases like closed markets, wide spreads, and resolution risks.

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 repeats the parameter types (slug, URL, text) and briefly mentions depth and include_raw defaults/effects, but adds little semantic nuance beyond the existing schema descriptions.

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

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

The description opens with 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call,' which is a specific verb+resource+method. It distinguishes from sibling tools like ask_pipeworx and deep_research by explicitly targeting Polymarket betting decisions.

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

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

The description explicitly states use cases: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also gives concrete examples of classifier-specific fan-outs. However, it does not explicitly mention when not to use this tool or list alternative tools.

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

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

Annotations already indicate safety (readOnly, idempotent, openWorld). Description adds valuable behavioral details: parallel call, data sources (SEC EDGAR/XBRL, FAERS), handling of off-calendar fiscal years, sorting by primary metric, and citation URIs. No contradictions.

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

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

Description is detailed but each sentence adds value. Structured with query examples, usage directive, parameter clarifications, and result format. Could be slightly more concise, but no wasted words.

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

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

Given 2 required parameters and no output schema, the description fully covers purpose, input format, data details, sorting, and alternative guidance. Agent can confidently invoke tool correctly.

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

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

Schema coverage is 100%, so baseline 3. Description adds meaning: explains type values with data pulled (financial vs adverse events), clarifies values array format (tickers/CIKs vs drug names), and specifies min/max items. Provides examples beyond schema.

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

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

Description clearly states it provides side-by-side comparison of 2-5 companies or drugs, with specific query examples. It distinguishes from sibling tools (e.g., entity_profile) by explicitly recommending this over sequential single-entity lookups.

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 'ALWAYS PREFER over sequential single-pack lookups when comparing entities,' providing clear when-to-use guidance. Does not explicitly state when not to use, but context implies it is for comparisons only, which is adequate.

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 well beyond the annotations, disclosing account requirements, paid-plan limits, latency expectations (15-60s, up to ~90s for thorough), parallel routing behavior, gaps[] for unanswered facets, contradictions[] scanning, semantic excerpting of long records, and the conditional presence of citation_uri. It also clarifies that the tool never invents answers. This is rich, honest behavioral context.

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

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

The description is long but information-dense; nearly every sentence contributes unique operational detail. It opens with a critical auth prerequisite and progresses through use cases, depth semantics, and output format. Structure is logical though not visually broken out, and some clauses could be tightened, but for a tool this complex the length is justified.

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

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

With no output schema present, the description takes on the full burden of explaining the return packet: findings, confidence, source, fetched_at, citation_uri, gaps[], contradictions[], and hop field. It also covers auth, cost, timing, and comparison to siblings. Nothing an agent needs to select, invoke, or interpret this tool correctly is missing.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful context beyond the schema: it explains the practical effect of depth levels ('standard re-angles unanswered gaps,' 'thorough additionally chases the best leads'), notes that 'standard' is default, and clarifies that 'thorough' is paid. The question parameter is illustrated with concrete examples. This 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 description clearly states what the tool does: 'Grounded multi-source research across Pipeworx's 1497 STRUCTURED data sources' with specific verbs like 'decomposes,' 'routes,' and 'returns.' It explicitly distinguishes itself from open-web search and from the sibling ask_pipeworx, making the tool's scope and identity 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 and actionable. It states when to use deep_research ('Best for broad/multi-part questions over structured data'), when to use ask_pipeworx instead ('For a single lookup,' 'For BREAKING or colloquial CURRENT-NEWS'), and even handles auth context ('If you are not signed in, use ask_pipeworx instead'). Alternatives are named and selection criteria are concrete.

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 readOnlyHint=true and idempotentHint=true, but the description adds valuable information: it returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples)' and notes each result is 'ready to call directly, no second schema lookup needed.' This goes beyond annotations by explaining output format and reusability.

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

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

The description is a single paragraph that front-loads the purpose. It is somewhat dense with examples and domain listings, but every sentence adds value. It could be slightly more concise, but it remains informative and structured clearly for an agent.

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

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

Given the tool has no output schema, the description compensates by explaining that it returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples).' It covers the limit parameter implicitly and explains the return format. For a discovery tool with 6 parameters and full schema coverage, this is fairly complete.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions that the query parameter accepts natural language and gives examples like 'analyze housing market trends,' but these are already present in the schema's examples. The description does not add significant new meaning or usage nuances for the parameters, so it stays at baseline.

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

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

The description clearly states the verb ('Find tools') and resource ('tools by describing the data or task'), and lists specific domains (SEC filings, FDA drugs, etc.). It differentiates itself from sibling tools by advising 'Call this FIRST when you have many tools available and want to see the option set.' This is a specific, valuable use case that sets it apart from other tools.

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

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

The description explicitly says 'Use when you need to browse, search, look up, or discover what tools exist for:' followed by a comprehensive list of topics. It also tells the agent to 'Call this FIRST' when exploring options. While it doesn't name specific sibling tools as alternatives, it provides clear contextual guidance for when to use this tool over others.

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 true, and destructiveHint false. The description adds valuable context: it fans out across multiple sources, soft-fails for patents (Sunset May 2025), and returns specific fields. 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 front-loaded with concrete query examples, then explains the multi-source behavior and return fields. It is relatively long but each sentence adds value. Could be slightly more concise by grouping similar info, but overall 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?

No output schema is provided, so the description must explain return values. It does so comprehensively: lists fields like cik, company_name, recent_filings (including URIs), fundamentals, patents (with caveat), news, LEI. This fully prepares the agent for the tool's output.

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 each parameter fully documented (type enum, value with format examples). The description essentially repeats the schema's guidance on value format. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description explicitly states the tool provides a full cross-source profile of a US public company in one parallel call, with example queries. It clearly differentiates from sibling tools like resolve_entity and compare_entities by specifying when to use this (holistic view) vs chaining other lookups.

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 ('ALWAYS PREFER over chaining...'), when-not-to-use ('names not supported — use resolve_entity first if you only have a name'), and notes preferred scenarios. This leaves no ambiguity for the agent.

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 destructiveHint=true. Description adds behavioral context (e.g., 'clear sensitive data') and confirms deletion of memory, supplementing annotations without contradiction.

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

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

Two efficient sentences: first defines purpose, second gives usage context. No wasted words.

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

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

Covers purpose, usage, and context adequately for a simple tool with one parameter and full annotations. No output schema needed, so completeness is high.

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

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

Schema coverage is 100% and the parameter description is clear. The tool description adds no further nuance about the key, meeting baseline but not exceeding.

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 ('Delete') and resource ('previously stored memory by key'), and distinguishes from siblings by naming 'remember' and 'recall'.

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

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

Provides explicit when-to-use conditions: 'context is stale, the task is done, or you want to clear sensitive data.' Also suggests pairing with related tools.

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

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

Annotations indicate readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds that the tool fetches the page, extracts key elements, and emits standard markdown. This aligns with annotations and provides useful context about the operation being non-destructive and idempotent.

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

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

The description is a single paragraph with no filler. The key action is front-loaded, and every sentence adds value: what it produces, how it works, and usage scenarios.

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 only 2 parameters, no output schema, and safety annotations, the description is fully adequate. It explains the output format, usage context, and behavior without gaps.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description does not add new semantic meaning beyond the schema; it just restates the purpose of the link limit implicitly.

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 uses specific verb 'Generate' and resource 'llms.txt file', and states the action: generates a production-ready llms.txt for any URL. It distinguishes itself from sibling tools by focusing on a specific output format and use case for AI crawlers.

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 lists three use cases: getting a client's site indexed, drafting for own project, or auditing competitor visibility. It does not specify when not to use or provide alternatives, but the guidance is clear and actionable.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by specifying the returned fields, confirming the scope (caller's subscriptions), and noting the optional parameter include_inactive. No contradictions.

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

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

The description is two sentences with no wasted words. The first sentence states purpose and returns, the second gives usage guidance. Well-structured and efficient.

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

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

For a simple tool with one optional parameter, no output schema, and comprehensive annotations, the description covers all needed context: what it lists, returned fields, and when to use it. No gaps.

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

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

Schema coverage is 100% (1 parameter fully described). The description does not add additional meaning beyond the schema's description of include_inactive. 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 explicitly states the verb 'list', resource 'subscriptions', and scope 'caller's active'. It lists returned fields, clearly defining what the tool does. This differentiates it from sibling tools like subscribe/unsubscribe.

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

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

The description advises using this tool 'before adding more subscriptions' or 'to find an id to cancel', giving clear usage scenarios. However, it does not explicitly mention when NOT to use it or suggest alternatives beyond the implied 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?

Annotations already indicate the tool is read-only, idempotent, and non-destructive. The description adds valuable context such as using OSRM, handling noisy traces, and returning geometry and confidence, which enhances transparency beyond annotations.

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

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

The description is a single, information-dense sentence with key aspects presented upfront. Every part is relevant, and there is no wasted text.

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 and the presence of an output schema, the description covers input format, optional parameters, and output characteristics. It is mostly complete, though a brief mention of the profile parameter would improve it.

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

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

Schema description coverage is only 33% (one of three parameters described in schema). The description partially compensates by explaining coordinates format and radiuses, but omits the 'profile' parameter, leaving ambiguity. Thus, it adds some but not sufficient 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 clearly states it map-matches a noisy GPS trace to a road network using OSRM with specific input format and optional parameters. However, it does not explicitly distinguish this tool from its sibling 'route', which may also involve routing, so it loses a 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 implies the usage scenario (noisy GPS trace matching) but does not provide explicit guidance on when not to use this tool or suggest alternatives. Sibling tools like 'route' exist but are not mentioned.

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, covering safety. Description adds the specific snapping behavior, which is consistent and provides context beyond annotations.

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

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

Single sentence, no redundancy, directly conveys the core function. No waste.

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?

Adequate for a simple snapping operation. Does not explain return behavior, but output schema may cover that. Parameter semantics are missing, but overall acceptable for a low-complexity 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 description coverage is low (25%), yet the description does not elaborate on any parameters (e.g., 'number' for alternatives, 'profile' for mode). It adds no semantic value beyond the schema.

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

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

Description clearly states the action ('snap'), the resource ('a single point'), and the target ('nearest road segment'). It is specific and distinguishes from sibling tools like 'route' or 'trip'.

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

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

No guidance on when to use this tool versus alternatives (e.g., 'route', 'match'). The description does not mention use cases or exclusions.

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

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

All annotations are 'false' (no safety hints), so the description carries full transparency burden. It discloses rate limiting ('5 per identifier per day'), quota exemption ('doesn't count against your tool-call quota'), the claim_token workflow (returned on filing, usable later via pipeworx_feedback), and team review cadence ('digests daily'). This goes well beyond the minimal mutation disclosure.

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. It is front-loaded with the core purpose, then progressively adds usage boundaries, token mechanics, rate limits, and quota status. No filler or redundancy; compact but information-dense.

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

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

Despite lacking an output schema, the description explains the key return artifact (claim_token) and its lifecycle. It covers when to use, when not to use, how to format feedback, and operational constraints. For a feedback submission tool with nuanced workflow, this is fully complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful workflow context for claim_token (how it's issued and re-used) and clarifies the relationship between type categories and user intent, enriching what the schema already documents. However, it does not elaborate on context/message beyond existing schema descriptions, so not a full 5.

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 starts with a clear, specific verb phrase: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It then enumerates concrete feedback categories (bug, feature/data_gap, praise) and distinguishes itself from sibling research tools by focusing on reporting issues about this specific Pipeworx connection.

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 when' conditions: wrong/stale data, missing catalog tool, or praise. It also gives a clear exclusion: do not report issues from other MCP servers, and directs users to those vendors instead. Additional guidance on describing issues in terms of Pipeworx tools/packs and not pasting end-user prompts further strengthens usage clarity.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds critical behavioral context: data source (CF analytics-engine), no PII, caching (5min-1h), and that it's a self-aggregating signal. 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 extremely concise: 3 sentences covering purpose, output, parameter guidance, and use cases. Information is front-loaded (first sentence states core function). Every sentence adds value 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?

Given a simple tool with 1 optional parameter, no output schema, and rich annotations, the description fully covers purpose, usage context, parameter behavior, caching, and data provenance. An agent has all information needed to decide invocation.

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

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

The only parameter 'window' is fully described in the schema with enum and description. The description adds extra meaning: 'Shorter windows surface what's hot right now; longer windows show steady-state demand,' which enhances decision-making beyond the schema.

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

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

The description clearly states the tool returns top tools, top packs, and total call volume over a recent window. It uses specific verbs ('returns', 'discovering', 'confirming') and distinguishes from siblings like 'ask_pipeworx' or 'discover_tools' by focusing on aggregate trending 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?

The description provides three concrete use cases (discovering hot data sources, confirming canonical tools, aligning use case) and explains how window size affects results. While it doesn't explicitly list when not to use or name sibling alternatives, the context is clear and actionable.

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

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

Discloses detailed behavioral traits beyond annotations (readOnlyHint, idempotentHint): includes semantic anchor, partition filter, fill check logic, and conditions for not trading (realizable_edge_pp <= 0). No contradiction with annotations; adds rich context for decision-making.

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?

Well-structured: first sentence states core purpose, then explains modes, technical details, response format, and fill check. Every sentence adds value without redundancy. Despite length, it is front-loaded and efficiently conveys necessary 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?

Comprehensive for a tool with 2 optional parameters and no output schema. Describes return fields (opportunities[] with gap_pp, suggested_trade, reasoning; partition_check with sum_yes_prices, etc.), covers edge cases (placeholders, similarity check), and explains fill check. Completely equips agent to understand tool behavior and 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% but description adds significant meaning: explains what each parameter does (e.g., event slug examples, topic seed questions), provides mode-specific behavior, and details underlying checks (partition_check, cross-event scanning). Elevates parameter understanding well beyond schema.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes between three modes: no arguments (trending_scan), event mode, and topic mode, each with specific behavior. This differentiates it from sibling tools like polymarket_edges and 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?

Explicit guidance on when to use each mode: 'Call with NO args for a trending_scan... pass event for... or topic for...'. Recommends event mode for specific markets and mentions using polymarket_fill_risk for custom sizing. Clear context and alternatives provided.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description adds significant behavioral context: caching at KV level keyed on all knobs (1 hour), details on how each segment computes its edge (e.g., lognormal barrier, GDELT volume ratio, partition_overround with bias correction, concentrated_longshot gates), and diagnostics to explain empty segments. 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 dense and technically detailed, but well-structured with clear sections (model families, tradeable-edge knobs, response structure). Every sentence provides specific information, though length is justified by complexity. It is front-loaded with the core purpose and then provides necessary depth. Could be more concise but remains effective.

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

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

Given the tool's complexity (9 parameters, 3 output segments, no output schema), the description thoroughly explains return value fields (edge_pp_net, kelly_fraction, kelly_fraction_half, market.liquidity, market.spread_pp, market.volume, 24h-move warning) and diagnostics (concentrated_longshot funnel counters, category_counts, filter_skips). The explanation of why Fed bets are excluded adds context. The description leaves no significant gaps for an agent to understand the tool's behavior.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds extra value by explaining the 'TRADEABLE-EDGE KNOBS' (min_liquidity, max_spread_pp, min_partition_leg_kelly) and their effect (e.g., 'knobs drop opportunities where edge isn't realizable'). It also clarifies how min_kelly and min_partition_leg_kelly interact differently for single-leg vs. partition opportunities. This additional context raises the score above baseline.

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

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

The description clearly states the tool's purpose: 'Scan top Polymarkets and return opportunities where Pipeworx data disagrees with market price.' It specifies the use case ('what should I bet on today') and breaks down the three response segments, distinguishing this tool from siblings by its focus on Pipeworx disagreement and edge scanning.

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

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

The description explicitly states when to use the tool ('agents discover opportunities without paging hundreds of markets'), explains the three model families and their conditions, describes tradeable-edge knobs for filtering, and notes that Fed bets are surfaced but excluded from ranking. This provides clear guidance on tool usage and alternatives.

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

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

The description extensively explains behavior beyond annotations: details return structure (tracked, expired, snapshot_dates), signed edge_pp_net, snapshot write conditions, gaps meaning, and TTL limits. 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 well-structured and every sentence adds value; it could be slightly more concise, but the information density is high.

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

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

Given the complexity and lack of output schema, the description provides a complete picture of return fields and behavioral nuances (decay computation, snapshot gaps, TTL), enabling correct agent usage.

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

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

Schema coverage is 100%, but description adds value by explaining default values and the meaning of 'window' as snapshot family, and clarifying the 'days' range (default 14, max 30) beyond schema's clamp.

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 answers 'how long has this edge existed and is it shrinking?' and distinguishes from sibling tools by focusing on persistence and decay telemetry from snapshots, not just current edges.

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

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

Provides clear context for when to use (to evaluate edge freshness vs. decay) and hints at why fresh vs. old edges matter, but does not explicitly mention when not to use or list 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?

Adds significant behavioral context beyond annotations (readOnlyHint, idempotentHint, destructiveHint false): walks the ladder, returns specific fields, explains basket mode risks (thin_legs, forced_directional_risk), and verifies partial fills convert arb into directional risk. 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 well-structured with headings (SINGLE-MARKET, BASKET), bullet points for return fields, and clear risk notes. It is somewhat lengthy but every sentence adds value given the complexity. Slightly verbose but appropriate.

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?

Fully covers input, dual modes, return fields, and risks. No output schema exists, but the description enumerates all return fields (top_of_book, vwap_fill_price, etc.) and explains basket-specific outputs (capture_ratio, profit_usd, thin_legs, etc.). Complete for a complex 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 description coverage is 100%, and the description adds value by explaining defaults (size_usd default 1000, side default auto), basket-mode interpretation of size_usd, and side auto-detection. It clarifies behavior beyond the schema.

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

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

The description clearly states 'Realizable-vs-theoretical edge check against live CLOB order-book depth', distinguishes single-market and basket modes, and specifies it should be used before acting on arbitrage signals or trades above $500. It differentiates from siblings like polymarket_arbitrage and polymarket_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?

Explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500' and explains risks. It also states 'REQUIRES one of `market` or `event`', providing clear when-to-use and when-not-to-use guidance.

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

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

Even though annotations already mark the tool read-only, idempotent, and non-destructive, the description adds extensive behavioral context: compatibility codes and their meanings, unclassified legs never being paired, pairing_unverified always set, gross-vs-net fee disclosure, and temporal alignment null semantics. It also explains counters like skipped_cross_type/subtype.

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 it earns its length: it is organized into modes, response, safety fields, code explanations, fee disclosure, and skipped-count semantics, and front-loads the core purpose before the caveats. No filler sentences are present and the structure makes the density navigable.

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 and no required parameters, the description must supply the full calling contract. It does: response shape, safety fields, possible codes, skipped-leg behavior, fee grossness, and caveats about pre-mapped topics. An agent has enough to decide when and how to call it and how to interpret the result.

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

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

Schema coverage is 100%, and the description goes further by explaining what each mode is for, that both modes run the identical overlap matcher, and what the explicit overrides do. It adds useful behavioral semantics beyond the field descriptions, though it doesn't address what happens when no parameters are supplied.

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

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

Opens with a specific verb-resource statement: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' The two-mode explanation makes it clear what it computes and how, and the phrase 'same resolving question' distinguishes it from the polymarket-only siblings in the list.

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 mode-selection guidance (pre-mapped topics vs explicit ticker/slug), warns that pre-mapped topics often return compatibility warnings, and sets expectations that gross spread is not automatically a tradeable edge. It does not explicitly name sibling alternatives or say when not to use the tool, 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?

Description adds scoping detail (anonymous IP, BYO key hash, account ID) beyond annotations. 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?

Three efficient sentences with front-loaded main action. No wasted words.

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

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

Covers usage, scoping, and sibling pairing. Lacks description of return format (string or list) but acceptable for simple 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 coverage 100%, baseline 3. Description explains that omitting key lists all saved keys, adding practical nuance beyond schema.

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

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

Description clearly states it retrieves a saved value or lists all keys. Distinguishes from siblings 'remember' and 'forget' by mentioning them explicitly.

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

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

States when to use (look up context stored earlier) and how to list all keys (omit argument). Does not explicitly exclude cases but pairs with siblings for completeness.

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 states that mark_read:true flags events as read, which modifies the feed state. This contradicts the annotation readOnlyHint=true, which implies no state mutation. The description does disclose this behavior, but the contradiction to annotations is a serious inconsistency that undermines trust.

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

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

The description is a single paragraph of five sentences, front-loaded with the core purpose. It is concise and each sentence adds value (purpose, return fields, filtering options, mark_read effect, alternative endpoint). Minor room for improvement in structuring with bullet points.

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

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

Given five optional parameters and no output schema, the description covers essential return fields, filtering, mark_read state change, and provides an alternative access method. It is sufficiently complete for an agent to use the tool effectively, though it could briefly mention pagination or limit behavior.

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

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

Schema coverage is 100% with descriptions for all five parameters. The description adds usage context (e.g., 'e.g. "sec_8k"' for type) but does not introduce new meaning beyond the schema. Baseline 3 is appropriate as the description merely reinforces existing schema information.

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 begins with 'Pull fired events from your subscription feed,' clearly stating the verb (pull) and resource (fired events). It further enumerates return fields (source, citation_uri, raw payload). However, it does not explicitly differentiate from sibling tools like 'recent_changes' or 'validate_claim', so it lacks explicit sibling differentiation.

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

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

The description provides explicit guidance on filtering by type and since, and on using mark_read to control read state for subsequent calls. It also mentions that polling works and provides an alternative endpoint for scripts/dashboards. However, it does not state when not to use this tool or suggest alternative tools for different use cases.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: the tool fans out to multiple sources, has a fallback chain (GDELT → GNews), and soft-fails for USPTO. This goes beyond the annotations.

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

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

The description is concise yet comprehensive. It front-loads the core purpose, then efficiently covers sources, parameters, and sibling differentiation without redundancy. Every sentence adds value.

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

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

Despite lacking an output schema, the description explains the return structure (changes[] grouped by source, total_changes count, citation URIs). It covers all essential aspects: purpose, parameters, sources, fallback, and when to use an alternative. Complete for a complex 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 coverage is 100%, so the baseline is 3. The description adds meaning by explaining the `since` parameter's relative shorthand (e.g., '7d', '30d') and the `value` parameter's accepted formats (ticker or CIK). This extra context justifies a score of 4.

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

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

The description clearly states it provides a change feed for a company in a time window, listing example queries and sources. It explicitly distinguishes from the sibling `entity_profile` tool, which is used for static profiles.

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

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

Explicitly states when to use this tool (for recent changes) and when to use `entity_profile` instead. Provides thorough guidance on the `since` parameter with examples, and explains fallback behavior among sources.

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?

Description adds behavioral details beyond annotations: persistence differences between authenticated (permanent) and anonymous (24 hours), scoped by identifier. No contradiction with annotations. IdempotentHint is consistent.

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?

Well-structured: purpose first, then usage guidance, then storage details, then pairing with other tools. Every sentence adds value without 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 no output schema, description fully covers behavior for an agent: what is stored, scoping, persistence, and how to retrieve/delete. No gaps.

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

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

Schema coverage is 100%, but description adds value with naming conventions for keys and examples for values. Significantly enhances understanding beyond 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?

Clearly states 'Save data the agent will need to reuse later' with specific verb and resource. Distinguishes from siblings recall and forget. Provides examples of use cases.

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

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

Explicitly says when to use: 'when you discover something worth carrying forward'. Mentions pairing with recall and forget. Provides concrete examples. Does not explicitly state when not to use, but context is clear.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses important behavioral traits: graceful degradation when LEI/FIGI enrichment is unavailable, explicit reporting of unresolved identifiers instead of omission, ambiguity handling via figi_candidates, and internal cascading across lookup endpoints. These details meaningfully prepare the agent for actual call outcomes.

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 usage examples and core guidance, then organized into SUPPORTED TYPES with detailed but relevant exceptions. It is dense and heavily parenthetical, so it is not maximally concise, yet most sentences carry necessary operational nuance for correct resolver usage.

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 compensates by explaining what results look like: canonical identifiers with source labels, explicit unresolved fields, figi_candidates for ambiguous matches, and ownership relationships. It covers both entity types, input edge cases, and failure modes, making it complete for a tool this complex.

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?

Although schema coverage is 100%, the description adds substantial meaning beyond the schema: it explains input formats for companies and drugs, gives ticker/CIK/ISIN examples, and warns against passing full noun phrases like 'revenue bonds' because trailing security-class words will fail. This significantly improves the agent's ability to construct correct parameter values.

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 verb and resource: resolve a user-spoken name to canonical/official identifiers required by other tools. It includes concrete usage examples ('What's the ticker for…', 'find the CIK for…') and differentiates itself from siblings by saying 'Use FIRST whenever you have a name but need an ID.' Supported types and identifier sources are explicit, making the tool's role 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?

The description explicitly instructs when to use the tool ('Use FIRST whenever you have a name but need an ID') and explains the scenarios it covers, including entity types and identifier sources. It does not explicitly name alternatives or state when not to use it, but it provides enough context to route an agent correctly.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds only 'fastest route' which is purpose-oriented, not behavioral. No mention of side effects, performance, or limits beyond annotations.

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

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

Single sentence with front-loaded verb and resource. No redundancy, every word 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?

Given the presence of output schema and detailed parameter descriptions, the description captures the essential function. However, lacks context for sibling differentiation and usage guidelines, leaving gaps for effective tool selection.

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

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

Schema description coverage is 100%, so all parameters are well-documented in schema. Description adds no extra meaning beyond the schema's parameter descriptions, meeting the baseline for this dimension.

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

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

Description clearly states verb (Compute), resource (route), and key constraint (fastest) with waypoints. It effectively communicates the tool's purpose but does not explicitly distinguish from sibling 'trip' which might be similar.

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

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

No guidance on when to use this tool vs alternatives like 'trip'. Missing information on prerequisites, suitable scenarios, or exclusions, leaving the agent to infer 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?

The description adds significant behavioral context beyond annotations: it reveals the tool probes each entity with ai_visibility_check, ranks by score, and returns a ranked list with score, confidence, and signal density. This fully discloses the mechanism and output. No contradiction with annotations (readOnlyHint, etc.).

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: purpose, mechanism, use case. Front-loaded with key information. Every sentence serves a purpose 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?

Given no output schema, the description explains the return format (ranked list with score, confidence, signal density) and notes the underlying probe call. It covers the main behavioral aspects, though it could optionally mention any error conditions or rate limits. Overall sufficient 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?

With 100% schema coverage, the description still adds value by clarifying that the first entity in the array is treated as the 'subject' for narrative purposes and explaining model options with usage notes (e.g., 'workers-ai' as default, 'anthropic' requires key). It adds meaning beyond the schema descriptions.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, using ai_visibility_check per entity and ranking results. It distinguishes from siblings like ai_visibility_check (single entity) and compare_entities (more generic).

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 directly states it is 'useful for competitive AI-marketing audits' and gives an example. While it does not explicitly exclude alternatives or provide when-not-to-use guidance, the context of comparing multiple entities implies it is the right choice for side-by-side analysis.

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

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

Annotations already indicate readOnly, openWorld, idempotent. Description adds concrete behavioral details: partial failures degrade gracefully, bundlephobia first measurement can take 5-30s, and sources_failed field lists timeouts. This goes beyond annotations.

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

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

Description is relatively long but well-organized: front-loaded with core purpose, then usage, then details. Every sentence adds value, though slightly verbose.

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

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

Given no output schema, description fully explains return block fields, partial failure behavior, and provides sufficient context for a complex composite 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 has 100% coverage, so baseline is 3. Description confirms package is npm name and version optional, mentions scoped packages and default to latest. Minimal additional meaning beyond 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 it is a composite check for adding npm packages, covering license, advisories, version history, and bundle size. It uses specific verbs and distinct resources, differentiating it from sibling tools.

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

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

Explicitly says when to use: 'when an agent asks is X safe/popular/small or what does adding lodash cost me'. Also states ecosystem limitation (npm only, v1) and points to alternatives for other ecosystems.

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, openWorldHint, idempotentHint, destructiveHint), the description adds rich detail: embedding model (BGE-base-en), window size (500-char overlapping), character cap (200K chars with truncation and flag), and offset guarantees for verification. 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 concise (4-5 sentences) and well-structured. It front-loads the purpose, provides usage context, and details behavior without unnecessary words. Every sentence adds value.

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

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

Given the tool has 3 parameters and no output schema, the description comprehensively covers input requirements, output format (passages with offsets and scores), behavioral details (embedding model, windowing, truncation), and pairing with other tools. It leaves no critical gaps for an AI agent to use the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful examples (e.g., 'supply-chain risk') and clarifies the types of text (SEC 10-K, article, tool result) and queries, enhancing understanding beyond the schema descriptions.

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

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

The description clearly states the tool performs semantic search inside a fetched record, specifying the verb 'search' and the resource 'inside a fetched record'. It distinguishes from sibling tools like ask_pipeworx_grounded by explaining the pairing and contrast with whole-document grounding.

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 this tool: 'Use when the record is too big to cram into the prompt' and provides an alternative: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document.'

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, description details OAuth requirement, delivery channel constraints (SMS verification/cap, webhook HMAC/auto-disable), and persistence limitations for anonymous/BYO accounts. 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?

Well-structured and front-loaded with purpose and return value. Some detail could be moved to schema descriptions, but the text is efficient and earns its 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?

Covers all necessary aspects: authentication, types, parameters, delivery channels, and return value (including one-time webhook secret). Complete for a subscription creation tool without output schema.

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

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

Despite 100% schema coverage, the description adds substantial value with type-specific examples and detailed constraints for delivery options, making parameter usage much clearer.

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 creates a proactive monitoring subscription and returns the new subscription ID. It distinguishes from siblings like list_subscriptions and unsubscribe by focusing on creation.

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 context for when to use (creating subscriptions) and important prerequisites (Pipeworx OAuth account). Does not explicitly state exclusionary cases, but the sibling context implies 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 annotations (readOnly, idempotent, etc.), the description adds behavioral context: it returns example questions with tool+argument shapes, and can be called with or without a topic. 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?

Front-loaded with user query examples, then explains output and usage. Slightly verbose with all categories listed, but compact for the value conveyed. Clear structure.

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

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

Despite no output schema, the description explains exactly what is returned (bucketed example questions with tool+argument shapes). Covers all necessary context for an onboarding tool: purpose, alternative meta-tools, optional parameter.

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% (1 optional parameter). Description adds meaning by listing example topic values ('finance', 'pharma', etc.) and explaining the default behavior when omitted.

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

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

The description uses specific verbs and resources: 'Returns category-bucketed example questions' with detailed categories (company financials, drugs, etc.). It clearly distinguishes from siblings by positioning itself as the 'onboarding entry point' for a new agent.

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: 'Use this FIRST when you do not yet know what Pipeworx can do for you' and 'or to learn how to call the meta-tools'. Also provides alternatives like ask_pipeworx, entity_profile, etc.

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 no additional behavioral context (e.g., rate limits, output format). With strong annotations, the description's minimal contribution is acceptable.

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, precise sentence that directly conveys the tool's core function with no extraneous words.

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

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

Given the complexity of a matrix computation tool (5 parameters) and the presence of an output schema, the description is adequate but could benefit from a brief note on output structure (e.g., 'returns a 2D array'). However, the schema covers parameter details, so the description is mostly complete.

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

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

Schema coverage is 100%; all parameters are described in the input schema. The description does not add new parameter information, meeting the baseline expectation.

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 'Distance / duration matrix between source and destination points' clearly identifies the tool as computing a matrix of distances or durations, which is distinct from sibling tools like 'route' (single route) or 'trip' (trip planning).

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 bulk distance/duration computation but offers no explicit guidance on when to use this tool versus alternatives like 'route' or 'trip'. The presence of sibling tools provides context, but the description itself lacks usage differentiation.

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 the tool as read-only, idempotent, and non-destructive. The description adds minimal behavioral context beyond 'solve', which aligns with the annotations. It does not disclose constraints like optimization strategy, result format, or input 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 a single concise sentence that efficiently conveys the core purpose. It avoids fluff, but the use of 'TSP-like' might require prior knowledge. Overall, it is well-structured for a simple tool.

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 presence of an output schema and informative annotations, the description provides minimal but adequate context. It lacks details on typical use cases, coordinate format (though examples exist), and how 'TSP-like' differs from exact TSP. For a tool with five parameters, it is somewhat underdescribed.

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 60%, covering source, roundtrip, and destination with basic descriptions. However, the required 'coordinates' parameter and 'profile' lack descriptions. The tool description does not add clarity for these parameters, missing an opportunity to explain format or acceptable values.

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 'solves a TSP-like trip between multiple waypoints', using a specific verb and resource. It implies optimization for multiple waypoints, distinguishing it from a simple routing tool like 'route'. However, it could be more explicit about the difference.

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

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

No guidance on when to use this tool versus alternatives like 'route' or other siblings. The description does not mention prerequisites, scenarios, or exclusions, leaving the agent to infer usage from the name and brief purpose alone.

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

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

Beyond annotations (destructiveHint=false), description explains behavioral nuance: 'The row is deactivated (not deleted) so its historical events stay available via recent_alerts.' Adds valuable context about side effects.

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

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

Two sentences, no wasted words. Front-loaded with core purpose, then adds ownership and behavioral details efficiently.

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

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

For a simple one-parameter tool with no output schema, description fully covers purpose, constraints, and side effects. No gaps for agent invocation.

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

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

Schema coverage is 100%, so baseline is 3. Description adds no further parameter details beyond schema (e.g., format or constraints), but this is adequate.

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

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

Description clearly states the action 'Cancel a subscription by id' with specific verb and resource. It distinguishes from siblings like 'subscribe' and 'list_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?

Explicitly states ownership enforcement: 'you can only cancel your own subscriptions.' Provides clear context on when to use but does not mention alternatives or when not to use.

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

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

Annotations already declare read-only, open-world, and idempotent behavior, so the bar is lower; the description still adds substantial context that goes beyond annotations. It explains the two processing pipelines, the meaning of each verdict status, and crucially distinguishes 'could_not_verify' (check did not happen, not evidence) from 'unsupported' (no source exists), plus the verification_error field. This is exactly the kind of behavioral nuance that agents need.

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 well-organized: trigger phrases, when-to-use, internal routing, return contents, a critical caller warning, and efficiency claim. Every sentence earns its place, and the structure front-loads the most useful detection cues. It is longer than the TDQS 4.3 example, but the complexity of the tool and the need to explain error semantics justify the length. A score of 4 recognizes the excellent structure without penalizing the necessary 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?

Despite having no output schema, the description fully covers the return value: verdict enum, actual value with pipeworx:// citation, and reasoning. It also explains the error semantics (could_not_verify vs. unsupported), the tolerance override, and the routing logic. Given the tool's two-path complexity and the absence of an output schema, the description is exceptionally complete and leaves no major ambiguity.

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 meaningful guidance beyond the schema for tolerance_pct: 'Overrides the tolerance implied by the claim wording — set 1–2 for hallucination detection where any material error must be refuted. Default: implied by wording, capped at 5.' The claim parameter also receives illustrative examples in the schema, which the description reinforces. This extra context justifies a score above baseline, though not the top as no additional parameter-level semantics are added.

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 and resource: 'natural-language claim verification against authoritative sources.' It is prefixed with concrete trigger phrases (""Is it true that…" / "fact check" / "verify the claim that…"") and differentiates from sibling tools by describing its distinct internal routing (SEC EDGAR fast path vs. grounded pipeline) and its single-call replacement of 4–6 sequential steps.

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 usage guidance is given: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also provides an internal decision rule (company-financial claims vs. any other factual claim) and notes that it replaces multiple sequential calls, which implies when to choose this over lower-level alternatives.

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