Riot Games

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false; description adds regional API detail but no additional behavioral traits like rate limits or error handling.

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

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

Single sentence, front-loaded with essential info, but could be more structured (e.g., separating purpose and parameters).

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 simple tool with output schema and annotations, description covers purpose, key fields, and regional limitation; no missing critical information for typical use.

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

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

Schema coverage 0% with no parameter descriptions; description mentions 'by puuid' and lists regions but does not detail parameter formats or constraints (e.g., puuid string format), partially compensating.

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 'Look up a Riot account' with specific fields (game_name, tag_line, puuid) and distinguishes from sibling account_by_riot_id by specifying lookup key (puuid) and regional API.

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?

Specifies regional scope (americas, europe, asia) and key (puuid), implying alternative account_by_riot_id for riot_id lookups, but lacks explicit when-not guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds no behavioral context beyond the annotations, such as error handling, rate limits, or authentication needs. It is a missed opportunity to add value.

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

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

The description is extremely concise (4 words), which is good for brevity but lacks structure. It front-loads the purpose but omits any elaboration. It earns its place but could be expanded slightly for clarity.

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

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

Given the presence of an output schema, the return values are covered. However, the description does not mention what happens when the Riot ID is not found, any prerequisites (e.g., valid region), or the relationship to other tools. Incomplete for a tool with 3 parameters.

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

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

Schema coverage is only 33%, yet the description does not clarify the 'tag_line' and 'game_name' parameters beyond the schema. The description does not compensate for the low coverage; it simply omits any parameter details.

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

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

The description 'Riot ID → account/puuid.' clearly indicates the tool converts a Riot ID to an account/puuid. The verb is implied (convert/resolve), and the resource is specific. It distinguishes from the sibling 'account_by_puuid' which likely does the reverse.

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 'account_by_puuid'. The description does not mention any prerequisites, limitations, or preferred contexts. The agent is left to infer usage from the name alone.

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

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

Annotations (readOnlyHint, idempotentHint, etc.) already signal safety. The description adds transparency about the return shape (per-model score, confidence, raw_response) and free/BYO cost model, which is valuable 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?

Two sentences, front-loaded with core purpose, no redundant language. Every part 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?

With no output schema and moderate complexity (4 params, 1 required), the description compensates fully by explaining the return structure, model options, auth, and optional features. It is complete for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds significant meaning: examples for entity, clarifies models and the dependency between _apiKey and anthropic model, and explains context disambiguation. This exceeds baseline 3.

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

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

The description clearly states the verb ('Probe'), resource ('LLMs for visibility'), and the scoring output (0-100 per model). It distinguishes from siblings like 'scan_competitor_ai_presence' by specifying per-model visibility 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 provides explicit usage context (AI-marketing audits, brand checks, competitive monitoring) and setup details (default free model, optional Anthropic with API key). It lacks explicit 'when not to use' statements but offers clear 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 establish read-only, open-world, idempotent, non-destructive behavior, and the description adds useful operational context: it 'works on every tier,' is 'one fast call,' and returns stable citation URIs rather than just raw data. It does not discuss failure modes or rate limits, but for a non-destructive query tool the annotations plus these additions are strong.

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

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

The description is long but every section earns its place: preference rule, use cases, examples, default behavior, and escalation paths. Key guidance is front-loaded with 'PREFER OVER WEB SEARCH,' and the structure moves from broad strategy to specific alternatives without repetition.

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

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

Despite the absence of an output schema, the description states what the caller gets ('structured answer with stable pipeworx:// citation URIs'), what counts as a good input, and how this tool compares with alternatives. For a single-parameter 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?

The schema fully documents the single required question parameter and its aliases, which sets a baseline of 3. The description adds value with real-world examples across stocks, filings, drugs, patents, weather, and clinical trials, clarifying what kinds of natural-language inputs the tool expects beyond the schema's examples.

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

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

The description names a precise role: routes a natural-language question into 5,724 tools across 1,497 verified sources and returns a structured answer with pipeworx:// citation URIs. It also differentiates from ask_pipeworx_grounded and deep_research, making it distinguishable from the closest siblings.

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

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

The description is explicit about when to reach for this tool: 'PREFER OVER WEB SEARCH,' 'START HERE for most questions,' and it gives concrete cue phrases ('what is', 'look up', 'get the latest') plus examples. It also states when to escalate to ask_pipeworx_grounded or deep_research, so an agent gets both inclusion and exclusion criteria.

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

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

The annotations already mark it read-only and non-destructive, but the description adds critical context beyond that: experimental routing improvements can be live, none is active now, and results are compared against the stable router. This gives an unusually clear picture of reliability and current behavior.

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

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

Four sentences each serve a distinct purpose: identity, current status, usage guidance, and reliability caveat. It is front-loaded with the core purpose and contains no redundant or filler sentences.

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

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

The description covers everything an agent needs beyond the schema and annotations: experimental nature, current parity with the stable router, comparison behavior, and fallback semantics. It also references the same response shape as ask_pipeworx, which adequately compensates for the absent output schema.

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

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

Schema description coverage is 100%, so the schema already documents the question field and its five aliases. The description adds only that the arguments match ask_pipeworx, which is useful context but does not meaningfully deepen parameter understanding beyond the schema.

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

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

The description explicitly identifies this as a beta version of ask_pipeworx and calls it a universal router, specifying exactly what is identical: 5,724 tools, same arguments, and same response shape. This clearly differentiates it from the stable ask_pipeworx sibling and the grounded variant.

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 an explicit use condition: use it exactly like ask_pipeworx when you want the newest routing. It also clarifies the current no-candidate state and states that this is a full working router, not a fallback, so an agent knows when and how to invoke it.

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

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

Annotations already signal readOnly, openWorld, idempotent, and non-destructive, but the description adds substantial beyond that: it reveals the refusal behavior with exact refusal_reason values, the success response shape, and the extra LLM call cost. No contradiction exists between the description and 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 dense but every sentence earns its place: behavior definition, routing comparison, success/refusal contracts, use cases, and cost trade-off. It front-loads the primary purpose and then details, without repeating schema or annotation fields.

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

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

For a complex meta-tool that routes across 5,724 tools, this description is complete: it defines the input (natural-language question), the process, the exact return contract with refusal reasons, and when to prefer the lighter sibling. No output schema exists, so the inline return and refusal shape are necessary and provided.

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 all aliases, is already documented as equivalent to 'question' in natural language. The description adds no parameter-specific detail beyond the overall grounded-answer behavior, so the baseline-3 score applies because the schema does the heavy lifting.

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

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

The description names a specific mode ('Hallucination-resistant answer mode'), a clear resource ('high-stakes reads' via ask_pipeworx routing), and a distinctive behavior: extracting answers only from the tool result and refusing when data does not directly answer. It explicitly contrasts itself with ask_pipeworx by saying 'Same routing as ask_pipeworx' but then adding the extraction step, so the agent can tell them apart without opening schemas.

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

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

It gives explicit when-to-use guidance: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts,' followed by concrete examples. It also names the alternative and the trade-off: 'Costs one extra LLM call vs ask_pipeworx — prefer ask_pipeworx for casual lookups.'

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

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

The description goes far beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) by detailing resolution confidence, parent event extraction, news fallback mechanisms, safety short-circuits for low-confidence matches, closed market handling, and cancellation rule parsing. 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 quite long and dense, covering many details. While each section adds value, it could be more concise. It is structured with clear sections (classifiers, fan-out examples, response shapes, resolver contract, etc.), but the length may overwhelm 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 complexity of the tool (no output schema, 3 parameters but intricate behavior), the description is exceptionally complete. It covers resolution rule risk, parent event extraction for partitioned bets, news error handling, illiquid market warnings, and both closed-market and low-confidence short-circuit paths. Everything an agent needs to use the tool correctly is present.

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

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

All three parameters are described in the schema with 100% coverage. The description adds extra context: explains the market parameter accepts slug/URL/question text, states default for depth is 'thorough', and recommends include_raw=false. This adds value beyond the schema.

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

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

The description clearly states it researches a Polymarket bet by pulling Pipeworx data, specifying input types (slug, URL, question text) and output structure. It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges through its comprehensive data aggregation purpose, though it doesn't explicitly compare with them.

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

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

Provides explicit usage contexts like 'should I bet on X' and lists category-specific fan-out examples. It gives clear guidance on when to use the tool but lacks explicit when-not to use or direct alternatives, which is acceptable given the comprehensive examples.

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, open world, and idempotent. The description adds behavioral context by listing the specific data fields returned (mastery level, points, chest granted, tokens earned), which is beyond what annotations provide. No contradictions.

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

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

The description is a single concise sentence that front-loads the main action and key details. Every part is essential, with no wasted words.

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

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

The tool is simple with 2 parameters, and an output schema exists to define return values. The description covers the main purpose and data fields. It does not mention pagination, ordering, or rate limits, but given the annotations and simplicity, it is sufficiently complete for an agent to understand 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 0%, so the description must compensate. It explains that the parameters are a puuid (player ID) and a platform (region), which clarifies their purpose but does not provide format constraints or valid values. Given the simplicity of the parameters, this is adequate but minimal.

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: returns a full champion mastery list for a puuid on a platform, specifying the fields returned (mastery level, points, chest granted, tokens earned). This distinguishes it from the sibling 'summoner_top_mastery', which likely returns only top champions.

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

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

The description implies usage (to get complete mastery data for a player on a platform) but does not explicitly state when to use this tool versus alternatives like 'summoner_top_mastery'. No exclusion criteria or prerequisite conditions are 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=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. However, the description adds no behavioral context beyond these hints, such as data freshness, rate limits, or the scope of the rotation (e.g., what region the platform refers to).

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 short (3 words) but at the expense of informativeness. While it is concise, it is under-specified and does not earn its place given the lack of 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 the existence of an output schema (indicated by context signals), the description provides no information about what the tool returns (e.g., a list of champion IDs or names). The description is incomplete for a tool with one required parameter and no parameter documentation.

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

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

Schema description coverage is 0%. The only parameter 'platform' has no description, and the tool description does not explain what values are valid (e.g., server region codes like na1, euw1). The description adds no semantic meaning beyond the raw schema, failing to compensate for the lack of 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 'Free champion rotation' is a phrase rather than a clear verb+resource statement. It does not explicitly state what the tool does (e.g., 'Get the current free champion rotation for a given platform'). The name suggests the purpose, but the description is insufficient for unambiguous understanding.

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 usage guidance is provided. There is no indication of when to use this tool versus alternatives like champion_mastery, nor any mention of prerequisites or contextual hints for calling the tool.

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

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

The description adds significant behavioral context beyond the annotations: for companies, it pulls specific financial metrics from SEC EDGAR/XBRL and handles off-calendar fiscal years; for drugs, it pulls FAERS, FDA, and trial data. It also notes results are sorted by primary metric and include pipeworx citation URIs. 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 concise yet comprehensive, with front-loaded examples and imperative instructions. Every sentence serves a purpose—no fluff. It structures information logically: examples, usage preference, type-specific details, and output format.

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

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

Despite lacking an output schema, the description covers return data (paired data, sorted, with citation URIs) and input/behavior adequately. For a simple 2-parameter tool, it provides complete context for selection and invocation.

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

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

With 100% schema coverage, the description adds valuable meaning: it explains that 'type' determines data source (SEC vs FAERS) and 'values' format (tickers/CIKs vs drug names). It provides concrete examples (AAPL, MSFT; ozempic, mounjaro), enhancing schema details.

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

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

The description clearly states the tool performs side-by-side comparisons of 2–5 companies or drugs in one parallel call, with specific query examples ('compare X and Y', 'which is larger'). It explicitly distinguishes itself from sequential single-pack lookups, establishing a unique purpose.

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

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

The description includes an explicit directive: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It specifies when to use the tool (comparison queries) and provides context on data sources per entity type, helping the agent decide between this and sibling tools.

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

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

Beyond the readOnly/idempotent annotations, it discloses account/payment requirements, parallel delegation, output packet fields, gaps[] with no invented answers, contradictions[], citation_uri resolvability, semantic excerpting, and worst-case latency. There is no contradiction with the annotations; 'NOT open-web search' clarifies the source type rather than conflicting with openWorldHint=true.

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?

Long, but every sentence carries a distinct decision-relevant fact and it is front-loaded with the account gate before purpose, routing, behavior, and latency. There is no filler or repetition.

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

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

With no output schema, the description fully specifies return semantics (findings packet, confidence, source, fetched_at, citation_uri, gaps[], contradictions[], hop) plus auth, alternatives, and timing. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema coverage is already 100% and the depth enum is well documented, so the baseline is met. The description adds decision-relevant extras: depth:'thorough' requires a paid plan, and the concrete multi-part question examples clarify what 'question' is expected to accept.

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 leads with 'Grounded multi-source research across Pipeworx's 1497 STRUCTURED data sources... in ONE call' and pins the exact use case: 'Best for broad/multi-part questions over structured data.' It also names what the tool is not ('NOT open-web search') and differentiates it from ask_pipeworx, so an agent can distinguish them without opening the schemas.

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

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

It gives explicit routing rules: use ask_pipeworx if not signed in, for single lookups, and for breaking/colloquial current-news topics; use deep_research for broad multi-part structured-data questions. Even depth-level guidance ('standard re-angles unanswered gaps', 'thorough chases leads') tells the agent which configuration fits the task.

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. The description adds valuable behavioral context: results include names, descriptions, full schemas with examples, ready to call directly.

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?

Concise yet comprehensive: front-loaded with purpose, lists domains, explains output format, and provides usage guidance. Every sentence contributes meaningfully.

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

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

Despite no output schema, the description fully explains what is returned (top-N tools with names, descriptions, schemas, examples) and when to use. Complete for a discovery 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% with detailed descriptions for all 6 parameters. The description includes example queries but does not add significant semantic value beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists specific domains and explains it returns top-N relevant tools with full schemas, distinguishing it from any sibling tool.

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

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

Explicitly advises 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' Provides clear context for when to use, though it doesn't mention 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 indicate readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond this: it describes the parallel fan-out across multiple sources, the soft-failure of the USPTO PatentsView API (sunset May 2025), the fallback mechanism (GDELT→GNews), and the specific data fields returned. This is strong disclosure beyond annotations, though a few more details about rate limits or error handling could push it higher.

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 efficiently packed with essential information, starting with example queries to quickly convey purpose. Every sentence earns its place: usage preference, source list, output details, limitations, and fallback behavior. There is no extraneous text, but also no omitted critical details. The structure is front-loaded and logical.

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 the tool's complexity (aggregating multiple data sources) and the absence of an output schema, the description thoroughly explains what the agent can expect: specific fields like cik, company_name, recent_filings with URIs, fundamentals, patents, news, and LEI. It also notes limitations (name not supported, USPTO API sunset). With only two simple parameters, this level of detail adequately completes the picture for an agent.

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

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

The input schema already provides a description for both parameters (type and value), achieving 100% schema description coverage. The description adds further value by explaining that 'value' can be a ticker or zero-padded CIK, gives examples ('AAPL', '0000320193'), and clarifies that names are not supported. It also notes that 'type' currently only supports 'company' and that other entity types are coming soon. This additional context enhances the schema's semantic clarity.

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: generating a full cross-source profile of a US public company. It provides specific example queries ('Tell me about X', 'research Acme') and lists the resources it aggregates (SEC EDGAR, XBRL, USPTO, news, GLEIF). It also distinguishes itself from sibling tools like resolve_entity and compare_entities by noting that names are not supported here and that resolve_entity should be used first if only a name is available.

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

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

The description gives explicit guidance on when to use this tool: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also states when not to use it (if only a name is available) and provides a clear alternative: 'use resolve_entity first.' This meets the highest standard for usage guidelines.

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 provide destructiveHint and idempotentHint. Description adds context about deleting stored memories and clearing sensitive data.

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

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

Two sentences, front-loaded with action and purpose, 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?

Tool is simple with one parameter; description fully covers purpose, usage, and sibling relationships. Output schema not needed.

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

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

Schema covers 100% of the single 'key' parameter. Description adds no 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?

Clear verb 'Delete' and resource 'memory by key'. Distinguishes from sibling tools 'remember' and 'recall'.

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

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

Explicitly states when to use: stale context, task done, clear sensitive data. Pairs with alternatives.

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

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

Annotations already indicate the tool is readOnly, idempotent, and non-destructive. The description adds behavioral context by explaining that it fetches the page, extracts title/description/links, and emits standard markdown format. It does not contradict annotations.

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

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

The description is concise at about 4 sentences, front-loaded with the main action and followed by use cases. It is efficient and contains no superfluous 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?

Given the tool's simplicity (2 params, no nested objects, no output schema), the description is complete enough. It explains the output format and typical use cases. Minor omission: does not mention potential errors or limits beyond the schema's max_links cap, but still sufficient for 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%, meaning the parameter details (url, max_links) are already fully documented in the schema. The description does not add additional meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool generates an llms.txt file for a URL, specifying the verb (generate), resource (llms.txt file), and context (for AI crawlers). It also lists specific use cases like getting a client's site indexed, drafting for own project, or auditing competitors, which differentiates it from sibling tools that are mostly unrelated.

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

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

The description includes explicit use cases ('Useful for: ...'), giving clear context on when to use the tool. However, it does not mention when not to use it or provide alternatives, but the purpose is sufficiently narrow to guide selection.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds only pagination, which is minimal behavioral context. It does not contradict annotations.

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

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

The description is a single sentence of 22 words, front-loading purpose and including examples. It is efficient and clear but could be slightly more structured with separate clauses.

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 5 parameters and an output schema, the description covers basic functionality but omits pagination details, parameter constraints, and any behavior about empty results. It is adequate but leaves 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?

With 0% schema description coverage, the description provides example values for queue, tier, division, and platform, and mentions pagination. However, it lacks explanations of each parameter's meaning, allowed values, or pagination behavior (e.g., page size). Some compensation but incomplete.

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

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

The description clearly states the verb 'List' and the specific resource 'ranked ladder entries', with explicit example values for queue, tier, division, and platform. This distinguishes it from sibling tools like champion_mastery or match.

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

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

The description implies usage for retrieving ranked ladder entries but provides no explicit guidance on when to use this tool versus alternatives like champion_mastery or match. No when-not-to-use or alternative recommendations are given.

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

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

Annotations already declare readOnlyHint, idempotentHint, and not destructive. Description adds specific return fields and behavior (active subscriptions). No contradictions, but does not mention edge cases like empty results.

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

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

Two sentences, front-loaded with purpose, no redundant information.

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

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

For a simple list tool with one optional parameter and strong annotations, the description covers purpose, return fields, and use cases adequately.

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

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

Schema coverage is 100% and parameter description in schema is clear. Description does not add new information beyond implying default filtering to active subscriptions.

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 'List the caller's active subscriptions' and lists return fields. It distinguishes from siblings like subscribe/unsubscribe as a read-only listing operation.

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 to review what you're monitoring before adding more or to find an id to cancel', providing clear when-to-use guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint=true, and destructiveHint=false. The description adds value by specifying what data is returned (participants, champions, stats, etc.), which 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?

Single sentence is concise and front-loaded with the verb and resource. However, it could be more structured (e.g., bullet points) for clarity, but 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?

Given output schema exists, the description adequately outlines return content. However, parameter explanations are missing, and the description could be more comprehensive for a 2-param tool with no enums.

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 0%, so description must compensate. It gives an example with region and match_id but does not explain their meaning or valid values. Missing parameter descriptions reduce usability.

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 fetches full LoL match details by match ID, listing specific data like participants, champions, stats, etc. It distinguishes from sibling tools like match_ids_by_puuid (which only returns IDs) and match_timeline.

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

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

The description implies usage when match details are needed by match ID, but provides no explicit guidance on when not to use it or alternatives. Sibling tools are not referenced.

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, and idempotentHint=true. The description adds context about listing recent matches, filtering, and pagination, which complements the annotations without contradicting them.

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 front-loads the main purpose and lists key filters and pagination. No redundant 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 tool has 8 parameters and no schema descriptions, but has an output schema, the description covers filtering and pagination adequately. It implicitly covers required parameters through examples. Minor gap: no explicit mention of required parameters.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions queue, start/end timestamps, and pagination parameters, but does not cover all 8 parameters (e.g., 'type'). Examples partially help but lack full detail.

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

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

The description clearly states the action 'list', the resource 'match IDs for a puuid', and the scope 'regional cluster'. It also lists specific filters and pagination options, distinguishing it from siblings like 'match' or 'summoner_by_puuid'.

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

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

The description implies usage for listing recent match IDs by puuid with optional filters, but does not explicitly state when not to use or compare to alternatives. However, the context is clear enough for an AI agent to infer appropriate usage.

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

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

Annotations already indicate read-only, idempotent, open-world behavior. The description adds value by specifying the timeline granularity (per-frame, per-minute) and event types, which are behavioral details not captured by annotations. No contradiction.

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

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

Single sentence that is front-loaded with action and deliverable. No extraneous words. Every detail 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 an output schema (not shown) and annotations covering safety, the description explains the timeline content sufficiently. Minor gap: does not mention potential size or pagination, but not critical for a simple fetch 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 0%, so description should explain parameters. It mentions 'LoL match ID' and provides an example with region and match_id, but does not define valid region values or match_id format. The example only partially compensates.

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

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

The description clearly states the action (Fetch), the resource (per-frame event timeline for a LoL match ID), and the specific events (kills, item purchases, level-ups, building destructions) at each minute interval. This distinguishes it from sibling tools like match or match_ids_by_puuid.

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

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

The description does not explicitly state when to use this tool versus alternatives (e.g., match for full details). It lacks guidance on prerequisites or when not to use it. The sibling list is long but no explicit comparisons are made.

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 are all false (neutral), so the description carries the burden and it excels: it explains the claim_token mechanism, rate limiting (5 per identifier per day), that it's free and doesn't count against quota, and that the team reads digests daily. This provides rich behavioral context beyond the schema.

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

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

The description is long but every sentence earns its place: purpose, usage criteria, scope limitation, token mechanics, rate limit, and roadmap impact. It front-loads the core purpose and is well-organized, with no filler or repetition.

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

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

For a tool with 4 parameters, nested context, and a token-claim flow, the description covers everything needed for correct use: scope, alternate routing for foreign tools, token usage, and expectations. No output schema exists, but the description explains what the claim_token does to compensate.

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, but the description adds significant meaning: it explains how claim_token should be used ('pass it back later as pipeworx_feedback({claim_token:...})'), clarifies the type categories contextually, and tells what message should contain. Only slight gap is not detailing the nested context object, which is already well-described in 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 verb ('Tell the Pipeworx team') and resource (Pipeworx), and explicitly enumerates the categories of feedback: broken, missing, or needs to exist. It distinguishes itself from sibling tools like ask_pipeworx by framing it as feedback on the tool catalog itself, not a query tool.

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

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

Provides explicit when-to-use guidance ('Use when a tool returns wrong/stale data...', 'when a tool you wish existed isn't in the catalog...') and when-not-to-use (don't report tools from other MCP servers, file with that server instead). Also gives content guidelines (describe in terms of Pipeworx tools/packs, don't paste prompts).

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 safety traits; description adds self-aggregating, no PII, caching behavior, and data source. Adds meaningful 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?

Front-loaded with main output. A few extra sentences but all earn their place. Could be slightly tighter.

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?

Complete for a simple one-param tool: purpose, usage, caching, privacy. 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 covers 100% with enum description. Description adds nuance (shorter windows hot, longer steady-state). Adds marginal value.

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

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

Describes exactly what it returns (top tools, top packs, call volume) with time windows. Distinct from siblings which are about accounts, matches, etc.

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 lists three use cases (discovering hot data, confirming canonical tool, aligning use case). Lacks 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?

Annotations declare read-only, idempotent, non-destructive behavior. The description adds extensive behavioral context: algorithms (Jaccard similarity, partition sum), fill check with book depth, placeholder filtering, and response structure. 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: summary sentence, then mode breakdown, followed by algorithm details and response format. Every sentence adds necessary information for a complex tool. Could be slightly more concise, but efficient overall.

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 modes, algorithmic checks, fill analysis, no output schema), the description covers all essential aspects: usage, logic, response fields, and actionable guidance (e.g., don't trade if realizable edge ≤ 0). Highly 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% and schema descriptions are informative, but the tool description adds rich detail: examples of slugs, acceptance of full URLs, and explanation that topic triggers cross-event scanning. This is significant added value.

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

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

The description clearly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks. It distinguishes between three modes (trending_scan, event, topic) and explains their triggers, making the purpose specific and actionable.

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

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

It provides clear when-to-use guidance for each mode (no args, event, topic) and recommends event for specific markets. It also directs users to polymarket_fill_risk for custom sizing. However, it lacks explicit comparison to sibling tools like polymarket_edges, which could clarify when NOT to use this tool.

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

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

The description goes far beyond the annotations, detailing the three response segments (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT), edge calculation, response fields (edge_pp_net, kelly_fraction, etc.), filtering knobs, diagnostics for empty segments, and caching behavior. There is no contradiction with annotations.

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

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

The description is verbose and densely packed with technical details, which may overwhelm agents. It is front-loaded with the purpose but then dives into extensive model explanations. While structured with clear sectioning, it could be more concise to improve readability.

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

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

Given the tool's complexity (9 parameters, no output schema), the description is thoroughly complete. It explains the response structure (by_segment, fed_candidates, _diagnostics), caching, edge calculation, and filter knobs. There is no missing information for an agent to understand what the tool returns and how to use it.

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

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

Schema coverage is 100%, and baseline is 3. The description provides context for parameters (e.g., 'Tradeable-edge filter' for max_spread_pp) but largely reiterates schema descriptions without adding significant new meaning. It explains how knobs interact but does not substantially enhance parameter semantics beyond what the schema already offers.

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 Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It is specific about the verb and resource, and the phrase 'Built for "what should I bet on today"' provides a clear use case. The tool is well-distinguished from siblings by its unique focus on Pipeworx disagreement.

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

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

The description implies usage for discovering betting opportunities but does not explicitly state when to use this tool over siblings like polymarket_arbitrage or polymarket_edge_tracker. No when-not-to-use or alternative tool comparisons are provided, making the guidance implicit rather than explicit.

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

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

The description goes well beyond annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) by detailing response structure, field semantics (trend, decay_pp_per_day), limitations (60-day TTL), and data sources (daily closes). 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 lengthy but well-organized, front-loading the core purpose and then providing detailed output structure and limitations. Every sentence adds value, though minor redundancy exists (e.g., mentioning default values already in schema).

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 comprehensively details the response format (tracked[], expired[], snapshot_dates[]) and explains fields. It covers all necessary aspects: purpose, parameters, output, limitations, and data freshness.

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

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

Schema coverage is 100%. The description adds default values and clamps for 'days' (default 14, max 30) and lists enum options for 'window' (24hr, 1wk, 1mo) which are not in the schema, providing additional guidance beyond parameter descriptions.

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

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

The description clearly states the tool's purpose: answering 'how long has this edge existed and is it shrinking?' It specifies the resource (edge persistence and decay) and distinguishes from sibling polymarket tools by focusing on time-series telemetry.

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 when to use the tool, e.g., 'a fresh wide edge and a 3-week-old wide edge are different trades.' It implies usage context but does not explicitly list 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 (readOnlyHint=true, destructiveHint=false, idempotentHint=true) already indicate safe, non-destructive behavior. The description adds behavioral detail: it walks the order book ladder, returns a verdict (clean|degraded|cannot_fill), and warns that partial basket fills create unhedged 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 comprehensive but slightly verbose. However, it is well-structured with clear sections (REQUIRES, SINGLE-MARKET, BASKET, USE THIS), making information easy to scan. Every sentence adds value, but could be tightened slightly.

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

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

Given the tool's complexity (two modes, multiple return values) and the absence of an output schema, the description thoroughly explains all return fields (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict, theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill detail, thin_legs[], max_clean_notional_usd, forced_directional_risk). It also provides operational context about risk and 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 the description adds substantial meaning: it clarifies the interpretation of size_usd for buys vs. sells and singles vs. baskets, explains the default side logic for baskets, and details the implications of each parameter. This goes far beyond the schema descriptions.

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

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

The description clearly states it performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth'. It distinguishes between single-market and basket modes, lists specific return fields (top_of_book, vwap_fill_price, slippage_pp, etc.), and differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by explaining its role as a pre-trade check.

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: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. It explains why (theoretical overround on thin books is not capturable, partial basket fills convert arb to unhedged directional position), providing clear guidance on when and why to use this tool over alternatives.

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

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

Goes far beyond the read-only/idempotent annotations, disclosing that matching is done by keyword and word overlap rather than a shared resolution source, that Kalshi fees are not modeled, that unknown legs are never paired, and that temporal_alignment null is not confirmation of alignment. It also enumerates the safety fields and codes with exact meanings, making the tool's limitations highly visible.

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?

Though long, the description is densely packed and structured with labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS, Codes) that make it scannable. Every sentence carries useful operational or interpretive information, and the opening sentence states the core purpose before the elaborations.

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 documenting the response shape, safety fields, compatibility codes, skipped-leg counters, fee handling, and temporal alignment semantics. It leaves an agent with enough information to invoke either mode correctly and interpret potentially misleading results.

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

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

The input schema already covers all three parameters at 100%, but the description adds meaningful interaction semantics: topic auto-fetches a matching event, explicit ticker/slug overrides the mapped side, and both modes execute the identical matcher. This clarifies precedence and mode behavior beyond the schema's standalone parameter descriptions.

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

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

Opens with a specific definition: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question,' naming the exact resource and comparison being computed. It further distinguishes itself from sibling Polymarket-only tools by centering the two-venue pairing, and it lays out the two modes without ambiguity.

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 on when the spread is meaningful ('when the bet shapes are equivalent that delta is a real signal') and when it is not, plus an explicit warning that pre-mapped topics are not tradeable. It does not name sibling tools as alternatives, but it gives enough decision context for selecting between topic and explicit modes.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds valuable context: scoping by identifier, and pairing with related tools.

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

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

Three sentences, front-loaded with main action, no wasted words. Each sentence provides distinct, valuable information.

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

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

For a low-complexity tool with one optional parameter, the description fully covers purpose, usage, behavioral traits, and scoping. No output schema needed.

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

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

Schema covers the single parameter well (100% coverage). Description adds usage nuance: omit key to list all keys, providing practical guidance 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 uses a specific verb ('Retrieve') and resource ('value saved via remember'), clearly distinguishing its purpose from siblings (remember, forget). It explicitly states the two modes: retrieve by key or list all keys.

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?

Clearly says when to use ('look up context the agent stored earlier') and pairs with remember/forget. Implicitly suggests using when avoiding re-derivation, but does not explicitly list alternative tools for similar purposes.

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 and idempotentHint=true, which the description reinforces and extends by detailing the returned fields (source, citation_uri, raw payload) and the side effect of mark_read. No contradiction.

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

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

The description is concise yet comprehensive, front-loading the purpose and then efficiently covering behavior, parameters, and alternatives. 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?

Given all parameters are optional, no output schema, and annotations cover safety/idempotency, the description provides sufficient behavioral context (return format, filtering, mark_read effect) and even an alternative endpoint, making it complete for a read-only polling 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 baseline is 3. The description adds value by giving an example for 'type' ('sec_8k'), explains 'since' as ISO timestamp, and clarifies 'mark_read' behavior. This exceeds the schema's 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 'Pull fired events from your subscription feed' and 'Returns the most recent alerts', providing a specific verb and resource. It distinguishes itself from sibling tools like 'list_subscriptions' and other non-alert 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 advises that 'Polls work fine' and mentions an alternative endpoint for scripts/dashboards, implying suitable usage context. However, it does not explicitly state when not to use this tool or compare it to closely related siblings.

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

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

Annotations already indicate readOnlyHint, idempotentHint, etc. The description adds value by detailing data sources (SEC EDGAR, GDELT→GNews fallback, USPTO), window handling, and return structure. No contradictions with annotations.

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

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

Description is front-loaded with example queries, making the purpose immediately clear. It is moderately concise but covers necessary details; could be slightly more streamlined but is well-structured.

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

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

Given the complexity (multiple sources, fallback logic, parameter formats), the description is fairly complete. It explains return structure despite no output schema. Additional details like soft-failure for USPTO enhance completeness.

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

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

All three parameters have descriptions in the schema (100% coverage). The description adds practical context for 'since' (e.g., 'Use "30d" or "1m" for typical monitoring'), which enhances semantic understanding 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 it's a change feed for a company in a recent time window, with explicit examples like 'What's new with X' and 'latest on Y'. It distinguishes from sibling tool 'entity_profile' which is for static profiles, making the purpose unambiguous.

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

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

Provides explicit when-to-use examples and contrasts with 'entity_profile' ('Use entity_profile instead when you want the static profile...'). Also explains fallback behavior among data sources, giving clear context for usage.

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

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

Annotations include readOnlyHint=false (write operation) and idempotentHint=true. The description adds key behavioral details: key-value scoped by identifier, persistent memory for authenticated users, 24-hour retention for anonymous sessions. 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 four sentences long, front-loaded with the core purpose, and contains no redundant or irrelevant information. Every sentence contributes to understanding.

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

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

The description is complete for a simple storage tool: it explains storage mechanism, scoping, persistence, and companion tools. No output schema is needed given the simplicity.

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

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

Schema coverage is 100% with clear descriptions for key (memory key, example formats) and value (any text). The description adds example values (subject_property, user_preference) but does not significantly add beyond schema. Still, it provides useful context.

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

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

The description clearly states the tool's purpose: 'Save data the agent will need to reuse later...' and provides concrete examples like 'a resolved ticker, a target address, a user preference.' It distinguishes itself from siblings by naming recall and forget.

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: 'when you discover something worth carrying forward...' and mentions alternatives: 'Pair with recall to retrieve later, forget to delete.' This provides clear usage context.

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

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

Beyond the annotations (readOnly, idempotent, openWorld), it discloses ambiguous-result behavior (returns figi_candidates), graceful degradation when GLEIF/OpenFIGI are unavailable, explicit unresolved fields, source labeling, and internal cascading lookups. This gives an agent accurate expectations for a complex resolution call.

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 dense and well-organized: usage examples and the 'use first' rule come first, followed by supported types and caveats. It could be tightened, but each block contributes necessary behavioral information for a high-complexity 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?

For a resolver with no output schema, the description covers input varieties, return contents (RxCUI, FIGI candidates, unresolved), source coverage, and failure modes. It does not provide a full response shape, but it gives sufficient context for an agent to call it correctly.

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

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

The input schema already describes both parameters with 100% coverage, and the description adds meaningful edge-case semantics: pass only the entity name, never the full noun phrase, and provides the bond-specific warning about trailing security-class words. That extra guidance goes beyond the schema, though not by a huge amount.

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 is explicit about the verb and resource: it resolves user-spoken names to canonical/official identifiers, and it distinguishes itself as the first-stop for 'name -> ID' lookups. It does not name or exclude sibling tools like entity_profile or compare_entities, so it falls short of full sibling differentiation.

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

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

The description gives concrete when-to-use guidance: 'Use FIRST whenever you have a name but need an ID,' backed by examples covering several phrasing styles. It lacks explicit when-not-to-use guidance or named alternatives, but the use case is clearly scoped.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds behavioral context: it probes each entity with ai_visibility_check, returns a ranked list with score, confidence, and signal density. No contradictions.

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

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

Three sentences, front-loaded with purpose, then detailed behavior, then use case. Every sentence provides value with no redundancy.

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

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

Given no output schema, the description adequately explains the return (ranked list with score, confidence, signal density). It covers the probe mechanism, ranking, and selection of most/least recognized. For a multi-entity comparison tool, this is complete.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond schema by clarifying that the first entity in 'entities' is treated as the 'subject' and the rest as competitors. It also explains the purpose of the 'context' parameter (disambiguate common names).

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

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

The description clearly states it compares AI visibility across multiple entities, uses ai_visibility_check under the hood, and ranks results. It distinguishes from sibling tools like ai_visibility_check (single entity) and compare_entities (generic comparison) by specifying AI focus and the competitive audit use case.

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 a clear use case ('competitive AI-marketing audits') and an example question. It implies the tool is for comparing multiple entities, but lacks explicit guidance on when to use alternatives (e.g., ai_visibility_check for single entity).

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

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

Annotations already provide readOnly, openWorld, idempotent, and destructive hints. The description adds significant behavioral context: it fans out across two services, handles partial failures gracefully, and notes that bundlephobia's first measurement can take 5-30 seconds. 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 the core purpose and is information-dense. It could be slightly more concise, but each sentence adds value (ecosystem scope, return structure, failure behavior). 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?

Despite lacking an output schema, the description fully explains the return structure (summary block fields, advisory details, links, alternative versions) and behavioral edge cases (partial failures, timing). For a composite tool with two dependencies and no output schema, this is complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds minimal new meaning: it confirms that 'package' accepts npm scoped packages and that 'version' defaults to latest. These are already implied by 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's purpose: a composite check for evaluating npm packages (license, advisories, size) in one call. It distinguishes from potential alternatives by specifying 'NPM ecosystem only in v1' and directing other ecosystems to deps.dev:version. The use case is explicitly tied to agent queries about safety, popularity, and size.

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 is given: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also warns about bundlephobia timing and partial failures. The description mentions ecosystem limitations and points to alternatives, though it doesn't cover all possible exclusion scenarios.

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

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

Goes beyond annotations (readOnlyHint, etc.) by detailing internal mechanics: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap with truncation flagging.

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 concise paragraphs. Front-loaded with purpose, then technical details. No 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?

Thorough coverage given complexity: explains return format (passages with offsets/scores), pairing with other tool, technical limits. No output schema, but description suffices.

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%, baseline 3. Description adds useful context: max chars for text, example queries, range for limit, enhancing understanding.

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?

Clear verb ('Search within') and resource ('a Source'). Description explicitly states it performs semantic search inside a fetched record, distinguishing from siblings like ask_pipeworx_grounded by use case.

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?

Describes when to use: 'record is too big to cram into the prompt'. Mentions pairing with ask_pipeworx_grounded. Lacks explicit when-not-to-use but provides sufficient 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 declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, indicating a safe, read-only operation. However, the description adds no further behavioral context (e.g., error handling, output format) beyond what annotations provide.

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

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

At two words, the description is severely underspecified. It does not earn its place as informative content; it sacrifices clarity for brevity.

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

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

Despite having an output schema, the description is too vague to inform appropriate use. It lacks essential context such as what 'status' means, making the tool effectively undefined for an agent.

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

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

Schema coverage for the single parameter 'platform' is 0%, and the description fails to explain what values are valid or what the parameter represents. The description adds no semantic value beyond the empty 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 'Platform status.' is a vague tautology that restates the tool name without specifying what aspect of platform status (e.g., server health, API availability, user status). It fails to distinguish from numerous 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?

No guidance on when to use this tool vs alternatives. The description provides no context about typical use cases or when not to use it.

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

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

Annotations (readOnlyHint=false, idempotentHint=true) indicate mutation but safe retry. Description adds: requires OAuth account, returns subscription id, type-specific parameters, delivery details (email/SMS/webhook) with limits and prerequisites (phone verification, 10/day cap), webhook signing secret returned once. 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?

Front-loaded with main purpose, every sentence adds value. Length is appropriate for the complexity of the tool; no redundant 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?

Given 3 parameters with nested objects, no output schema, and diverse subscription types, the description covers all needed aspects: types, parameters, delivery options, prerequisites, limits, authentication, and security details for webhooks. Exceptionally complete.

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

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

Schema coverage is 100%, but description adds extensive meaning: explains type enum values with examples, details params object per type with required fields, and delivery sub-fields with usage examples and constraints (verified phone, email pattern, webhook signature).

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?

Clear verb (Create), resource (proactive monitoring subscription), and output (returns subscription id). Distinguishes from siblings like list_subscriptions, unsubscribe, recent_alerts by specifying that it creates a persistent subscription to live-data event streams.

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: when to use (proactive monitoring), prerequisites (Pipeworx OAuth account), constraints (anonymous/BYO cannot persist), supported types, and delivery channels. Does not explicitly exclude cases or compare with alternatives, but implies that for one-time checks, recent_alerts is appropriate.

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

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

Description adds significant behavioral context beyond annotations: it specifies that the tool returns example questions with exact tool and argument shapes, drawn from a live catalog. No contradiction with annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint false).

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 thorough but slightly verbose; however, every sentence contributes meaningful information. Front-loaded with canonical example queries and purpose, making it easy to scan.

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 role as an onboarding entry point, the description covers output format (category-bucketed examples with exact tool calls), usage scenarios, and scope. No output schema exists, but the description adequately compensates.

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

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

Schema coverage is 100% (1 optional parameter). Description adds value by listing example topic values ('finance', 'pharma', etc.) and explaining the effect of passing or omitting the topic, which is not fully captured in the schema's description.

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

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

Clearly states it is the onboarding entry point, returns category-bucketed example questions, and specifies the tool's role in helping users understand what Pipeworx can do. Distinguishes from siblings like ask_pipeworx, entity_profile, and compare_entities by explicitly mentioning them.

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

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

Explicitly advises to 'Use this FIRST' when the user does not know what Pipeworx can do, and explains how to call with no arguments or with a topic. Also mentions learning about meta-tools, providing clear guidance on when 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 provide readOnlyHint, idempotentHint, openWorldHint, destructiveHint=false. Description adds value by specifying the exact fields returned, which is not in annotations. 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?

Single sentence, front-loaded with key information, no unnecessary words. Extremely concise and easy to parse.

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

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

For a simple fetch tool, description covers required inputs and returned fields. Output schema exists to detail return values. Could mention platform format or validation, but overall adequate.

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 0%, so description must compensate. It mentions 'puuid' and 'platform' and gives example 'na1' but does not explain what puuid is or list valid platform values. Minimal additional meaning.

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

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

Description clearly states verb 'Fetch', resource 'LoL summoner details', lists specific fields (summoner ID, account ID, summonerLevel, profileIconId, revisionDate), and specifies key parameters (puuid, platform). It differentiates from siblings like account_by_puuid by focusing on summoner details.

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

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

Description implies usage context (for a puuid on a specific platform) but does not explicitly state when to use this tool versus alternatives (e.g., account_by_puuid, match_ids_by_puuid). No when-not or alternative guidance.

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

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

The description discloses the default count of 3, the return fields (championId, championLevel, championPoints, last play time, chest/token flags), and the data source (Riot Games API). These go beyond the annotations' read-only/idempotent hints, providing concrete behavior without contradicting the annotations.

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

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

The description is three sentences, front-loading the core purpose in the first sentence, then specifying return fields and the higher-level question answered. No filler words, and 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 there are only 3 parameters, an output schema, and annotations covering safety, the description provides all necessary context: parameters, defaults, return fields, and use case. It is complete for an AI agent to select and invoke the tool correctly.

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

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

The schema provides zero descriptions for any of the three parameters, but the description compensates fully: it defines puuid as 'one League of Legends account', platform as 'platform routing value such as na1, euw1, or kr', and count as 'controlling how many champions come back (default 3)'. This gives complete semantic meaning for invocation.

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

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

The description names a specific resource ('highest champion mastery entries for one League of Legends account') with a clear verb ('Returns'), and includes the question it answers ('which champions a League of Legends player has played most and mastered furthest'). This distinguishes it from generic sibling tools like champion_mastery by emphasizing 'highest' and 'top mastery'.

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 invocation parameters (puuid, platform, count) and states the intended use case (answering most-played/mastered champions). However, it does not mention alternatives or when not to use, so it stops short of full usage 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?

Beyond annotations (idempotentHint=true, destructiveHint=false), the description explains that the row is deactivated rather than deleted, keeping historical events available via recent_alerts. This adds valuable 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 two sentences: the first states the action and constraint, the second explains the side effect. No extraneous information.

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

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

For a simple tool with one parameter, no output schema, and provided annotations, the description fully covers purpose, usage constraint, and behavioral outcome 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?

With 100% schema description coverage for the single parameter 'id' (described as 'Subscription id (uuid) returned by subscribe'), the description adds no further meaning beyond the schema, meeting 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 'Cancel a subscription by id,' specifying the verb 'cancel' and the resource 'subscription.' It distinguishes itself from sibling tools 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?

The description indicates when to use the tool by mentioning ownership enforcement ('you can only cancel your own subscriptions'), providing clear context but not explicitly listing alternatives 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?

Annotations already provide read-only, open-world, idempotent hints, but the description adds crucial behavioral nuance: the distinction between could_not_verify (check did not happen, not evidence) and unsupported (we looked, no source), and the fast-path vs grounded pipeline. This directly prevents misuse and is exactly the type of context annotations cannot convey.

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

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

The description is front-loaded with trigger phrases, then gives use guidance, internal routing, return values, a critical caller warning, and a replacement note. Every sentence earns its place; the density is high without being verbose. It is well-structured for an agent to parse quickly.

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

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

No output schema exists, so the description must explain return values and semantics — and it does, listing the verdict enum, citation format, and the crucial distinction between could_not_verify and unsupported. For a tool with two parameters and complex behavior, this fully equips an agent to invoke and interpret it correctly.

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

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

Schema coverage is 100%, but the description adds significant parameter-level insight: tolerance_pct overrides implied tolerance, is suggested at 1–2 for hallucination detection, and has a default cap of 5. It also enriches claim with concrete examples. This goes well beyond the schema descriptions.

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

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

The description uses specific verbs ('verify', 'check', 'confirm or refute') tied to a clear resource ('natural-language claim verification against authoritative sources'). It is immediately distinguishable from sibling tools like ask_pipeworx_grounded or deep_research by focusing on true/false verdicts for factual claims. Trigger phrases and examples make the purpose unambiguous.

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

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

Explicitly states when to use: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also explains the routing logic (company-financial vs any other claim), which is strong contextual guidance. However, it does not explicitly mention when not to use an alternative tool like deep_research, so it falls short of 'explicit when/when-not/alternatives' at the highest bar.

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