Gleif

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

Annotations indicate readOnly, openWorld, idempotent, non-destructive. Description adds that probing uses free default model and requires BYO API key for Anthropic with direct payment. Discloses return format (score, confidence, signals, raw_response) and combined view. 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 paragraph is well-structured: purpose, conditions, return format, use cases. Front-loaded with primary action. Every sentence adds necessary information. No wasted words.

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

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

For a 4-parameter tool with no output schema, description covers usage, return format, and cost implication. Lacks explanation of how scoring works (0-100 scale) or what 'confidence' and 'signals' entail. Adequate but could add scoring methodology.

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 value: explains 'models' can be omitted for default, and '_apiKey' is only needed if Anthropic is used. Provides examples for entity and context. Adds 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?

Clearly states it probes LLMs for brand visibility scoring, specifies default model and API key requirement for Anthropic. Differentiates from sibling tools like scan_competitor_ai_presence by focusing on per-model 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?

Explicitly mentions use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Does not explicitly state when not to use, but context is clear. No alternative tool is named, but usage is well implied.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds valuable context: that the result includes 'stable pipeworx:// citation URIs', that it 'fills arguments' automatically, and that it works on 'every tier' with 'one fast call'. A minor gap is that it doesn't mention how long a typical call takes or any rate limits, but for a query tool this is sufficient.

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

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

The description is moderately lengthy but every sentence earns its place: it establishes preference over web search, lists covered domains, explains the routing mechanism, gives example queries, positions vs. siblings, and provides tier/performance info. It could be slightly tighter (e.g., the list of example queries is long), but it's well-front-loaded and highly informative.

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

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

Given the tool's complexity (routes to 5,564 tools across 1462 sources), the description covers the main categories clearly. There's no output schema, so the agent doesn't know the exact return format beyond 'structured answer with citation URIs', but this is acceptable for a query tool. The sibling comparison is thorough, and the covered domains list is comprehensive.

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

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

Schema coverage is 100% and the schema thoroughly documents all 6 parameters as aliases for the 'question' string. The description adds value by explaining what kinds of questions are appropriate and giving concrete examples, but the parameter semantics themselves (the meaning of the 'question' field and its aliases) are fully covered by the schema. Baseline 3 is correct.

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: answer factual questions about real-world entities, events, and numbers by routing to an authoritative, curated source base. It uses specific verbs ('answer', 'route', 'fill arguments', 'return structured answer with citations') and contrasts itself effectively with siblings like ask_pipeworx_grounded and deep_research, making its niche unmistakable.

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

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

The description provides exceptionally clear usage guidance: it explicitly says 'START HERE for most questions', 'prefer over web search', and gives a wide range of example queries. It also tells the agent exactly when to step up to other tools (ask_pipeworx_grounded for hallucination-resistant single answers, deep_research for broad/multi-part questions, and explicitly notes that for breaking news the tool already handles it). This is near-perfect decision support.

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 declare readOnly, idempotent, and non-destructive hints. The description adds valuable context: the beta nature, candidate routing under test, current inactivity of candidates, and that it falls back to nothing (full working router). This goes beyond annotations by explaining the experimental lifecycle and purpose.

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 three sentences, front-loading the key identity (Beta of ask_pipeworx) then covering current state, usage instruction, and fallback. Every sentence adds unique value without redundancy or fluff.

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

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

The description references the stable ask_pipeworx for full behavior (same tools, arguments, response shape), which suffices given sibling context. It explains the beta lifecycle and routing improvements. Minor gap: does not explicitly state that the router forwards questions to underlying tools, but this is implied by 'universal router' and 'same 5,564 tools'.

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

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

Schema coverage is 100% and all parameters are aliases for 'question' with clear descriptions. The description does not add new parameter details, only stating 'same arguments' as ask_pipeworx. Baseline 3 is appropriate since the schema already handles parameter meaning fully.

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

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

The description clearly states it is the beta version of ask_pipeworx, an identical universal router with the same 5,564 tools and arguments. It distinguishes itself as the experimental edge for candidate routing improvements, setting it apart from the stable ask_pipeworx and other 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 explicitly says to use it exactly like ask_pipeworx when wanting the newest routing, and contrasts it with the stable router for deciding merges. It also notes current identical behavior and references sibling ask_pipeworx_grounded implicitly, 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, and destructiveHint = false, so the description adds value by detailing the refusal mechanism (possible refusal_reasons), the return structure with evidence and source, and the cost trade-off (one extra LLM call). No contradictions with annotations.

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

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

The description is dense but clear, front-loading the core purpose. Slightly verbose with the refusal_reason list and return structure, which adds value but could be more concise. Still 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 large sibling tool set (38 tools), lack of output schema, and high schema coverage, the description fully explains the tool's purpose, usage, behavior, refusal modes, and cost trade-off. It is complete for an AI agent to correctly invoke and interpret results.

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

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

Schema coverage is 100% (all six parameters are documented as aliases for 'question'), and the description adds no additional parameter guidance beyond the schema. Baseline 3 is appropriate as the description doesn't explain acceptable question formats, length limits, or specificity hints.

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 this tool is a 'hallucination-resistant answer mode for high-stakes reads,' specifies it returns only data from tool results with evidence, and distinguishes it from the sibling ask_pipeworx by noting the extra LLM call cost and use case for authoritative answers.

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 tells when to use (high-stakes reads where answers will be quoted/cited/acted on, financial/legal/medical/public statements) and when not to (prefer ask_pipeworx for casual lookups due to extra cost), with concrete examples of use cases.

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

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

The description provides extensive behavioral details beyond annotations: resolution confidence, cancellation rules, market closed/inactive handling, wide spread handling, short-circuiting on low confidence, and response shapes. Annotations indicate readOnly, openWorld, idempotent, and non-destructive, which are consistent with the description.

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 excessively long and contains many internal implementation details that may not be necessary for an AI agent. While the front-loading of purpose is good, the overall verbosity reduces conciseness.

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

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

Given the complexity (3 parameters, no output schema), the description thoroughly covers all aspects: input formats, response shapes, error conditions, edge cases (e.g., closed markets, wide spreads), and resolution rules. It leaves no significant gaps for understanding tool behavior.

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

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

Schema coverage is 100% with descriptions for all parameters. The description adds meaningful context: explains the different input forms for 'market', notes the default for 'depth', and clarifies the use of 'include_raw'. This goes beyond the schema but is not exhaustive.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types and the overall workflow. It distinguishes from sibling tools by focusing on single-bet research rather than arbitrage or edge tracking.

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 suggests use cases: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' However, it does not explicitly state when not to use this tool or name alternatives, which would improve clarity.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds meaningful behavioral context beyond these: it discloses the fallback from branch BIC to head office and explicitly states that this fallback is surfaced to the user ('and says so'). It also names the data source (official GLEIF mapping), which helps set trust expectations.

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, each earning its place: first states the action and output, second gives examples and use cases, third explains the fallback nuance. It is front-loaded with the core purpose and contains no filler.

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

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

For a simple single-parameter lookup tool with no output schema, the description is sufficiently complete. It specifies the input format, output fields (LEI, legal name, jurisdiction, status), the data source, and an important edge-case behavior. An agent can confidently invoke this tool and interpret its 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 describes the 'bic' parameter with format examples and treatment of 8-character codes, so coverage is 100%. The description adds further semantic value by explaining the purpose of the input ('which legal entity is behind this BIC'), reinforcing the acceptable formats, and describing the fallback behavior that affects how the parameter is interpreted.

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

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

The description opens with a specific verb ('Resolve') and resource ('SWIFT/BIC ... to the bank's legal entity: LEI, registered legal name, jurisdiction, and status'), clearly distinguishing this from sibling tools like get_lei (which likely looks up by LEI directly) and isin_to_lei (which uses a different identifier). It also states the exact questions the tool answers.

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

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

The description provides clear usage context: it is for resolving BIC-to-LEI in KYC, due diligence, and payment scenarios. It does not explicitly name alternatives or exclusions, but the use case is specific enough that an agent can infer when to prefer this tool over generic entity 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?

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. Description adds useful behavioral context: pulls latest 10-K data, handles off-calendar fiscal years, sorts by primary metric, returns citation URIs. 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 and clear directive. Somewhat verbose in detailing each entity type, but every sentence adds value. Could be slightly more concise.

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

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

Given the complexity (two entity types, multiple data sources), the description covers what the tool does, what data it returns, and how results are sorted. No output schema, but return format is described sufficiently (paired data + citation URIs).

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%. Description adds meaning beyond enum values and descriptions: for 'company' it specifies revenue, net income, cash, debt; for 'drug' it specifies adverse-event counts, FDA approvals, trial counts. Also explains sorting behavior.

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 states it performs side-by-side comparison of 2-5 companies or drugs, specifying data sources (SEC EDGAR/XBRL for companies, FAERS/FDA/trials for drugs). Clearly distinguishes from sibling tools like entity_profile (single entity lookup) by emphasizing parallel comparisons over sequential lookups.

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

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

Explicitly says to prefer over sequential single-pack lookups and gives example queries. Does not provide explicit when-not-to-use scenarios, but context is clear that it's for multi-entity comparisons.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds substantial behavioral context: parallel decomposition across 5,564 tools, return format (findings packet with verbatim evidence, confidence, source, fetched_at, pipeworx:// citations, gaps[], contradictions[]), behavioral differences by depth (gap recovery hops, contradiction scanning), latency (15-60s, up to ~90s), and semantic excerpting behavior for large records. One minor gap: it doesn't explicitly state that results are fetchable via the resources/read endpoint using citation_uri, though this is strongly implied.

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

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

The description is dense and informative but somewhat unstructured—it front-loads the account requirement (critical), then mixes usage guidelines, return format, behavioral details, and depth differences in a single paragraph without clear separation. While every sentence provides value, the lack of sectioning (e.g., bullet points or paragraphs for when-to-use, return format, depth behavior) makes it harder to scan. It earns points for being comprehensive but loses on scannability.

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 (broad multi-faceted research across 1462 sources, 3 depths, parallel decomposition, gap recovery, contradictions, citations) and the absence of an output schema, the description provides remarkably thorough coverage: input requirements (account, paid for thorough), return format details, behavioral differences across depths, limitations (not for news/lookups), latency expectations, and citation semantics. All critical behavioral aspects are covered, leaving no obvious gaps for an agent to misinterpret.

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 both parameters (question, depth) are fully documented in the schema. The description adds value by explaining the behavioral implications of each depth value (quick=3 facets single hop, standard=3 with gap recovery, thorough=6 paid with iterative chase). However, the description of the 'question' parameter adds no new meaning beyond what the schema provides ('The research question, in natural language. Broad/multi-part is fine — decomposition is the point.'). With full schema coverage, the baseline is 3, and the depth explanation justifies moving up slightly, but the question parameter adds no extra 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 this tool performs 'grounded multi-source research across Pipeworx's 1462 STRUCTURED data sources' in one call, with a specific verb ('research') and resource ('structured data sources'). It contrasts with siblings like ask_pipeworx (single lookup) and explicitly notes this is not open-web search, providing excellent differentiation.

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

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

The description provides explicit when-to-use guidance ('Best for broad/multi-part questions over structured data'), when-not-to-use ('For a single lookup use ask_pipeworx', 'For BREAKING...prefer ask_pipeworx'), and clear alternatives named (ask_pipeworx, ask_pipeworx for news). It also details account requirements and fallback if not signed in.

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 confirm readOnly, idempotent, non-destructive. Description adds that results include full input schemas with curated examples, ready to call directly, which is consistent and informative 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 purpose and examples, 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?

Given the tool's role as a discovery tool, the description covers what it does, when to use, and what it returns (top-N tools with full schemas). Schema coverage and annotations are complete, output format is explained.

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

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

Schema description coverage is 100%, all parameters are documented. The description adds no new parameter-level meaning; it only restates the purpose of the query parameter. Per guidelines, baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: to find tools by describing data or task, with specific examples of domains (SEC filings, FDA drugs, etc.). It distinguishes itself from sibling tools by being the discovery/introductory tool, no other sibling serves this role.

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

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

Explicitly advises to 'Call this FIRST when you have many tools available' and explains it returns ready-to-call options. This provides clear when-to-use guidance, though it doesn't enumerate when not to use (implied by FIRST).

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, openWorldHint, and non-destructive. The description adds context about the multi-source fan-out, specific data fields, and known limitations (USPTO PatentsView API sunset with soft-fail behavior). This goes beyond annotations without contradiction.

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

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

The description is information-dense but well-organized, starting with examples and then explaining functionality and limitations. Every sentence serves a purpose, though slightly longer than necessary. It remains efficient for the complexity covered.

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 thoroughly explains the returned data: specific fields from each source, URIs for filings, and soft-fail behavior. It covers edge cases (sunset API, name resolution) and fully prepares the agent for invocation.

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

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

Schema coverage is 100%, so the schema already describes parameters. The description adds practical guidance: value can be ticker or zero-padded CIK, names not supported. It also explains the type parameter is limited to 'company'. This enhances 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 provides multiple concrete query examples ('Tell me about X', 'research Acme'), specifies the scope (US public companies), and lists return fields (cik, filings, fundamentals, patents, news, LEI). It contrasts with siblings like resolve_entity and chaining single-source lookups, making 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 (holistic cross-source profile) and when not to use (names not supported, advises to use resolve_entity first). Also provides a clear preference rule: 'ALWAYS PREFER over chaining single-pack… lookups when the user asks for a holistic view.'

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

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

Annotations already mark destructiveHint=true and idempotentHint=true. Description adds 'Delete' which is consistent. No extra behavioral context like error handling or key-not-found behavior. Minimal added value 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: first defines action, second provides usage guidance. No redundancy, perfectly concise. Front-loaded with the core purpose.

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 one parameter and no output schema, description covers purpose, usage, and complementary tools. Could mention behavior on missing key, but overall complete for its 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?

Only one parameter 'key' with schema description 'Memory key to delete.' Description field adds no additional semantics beyond what schema provides. Schema coverage is 100%, so baseline 3 is appropriate.

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

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

The description clearly states 'Delete a previously stored memory by key,' specifying the action and resource. It mentions pairing with remember and recall but doesn't explicitly differentiate from recall (which retrieves). Purpose is clear and specific.

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

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

Provides explicit use cases: when context is stale, task done, or clearing sensitive data. Doesn't specify when not to use, but complementary siblings (remember, recall) imply usage scope. Adequate 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=False. The description adds that it fetches the page, extracts title/description/key links, and emits standard markdown, which aligns with annotations and provides additional behavioral context. 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 concise, with only three sentences that cover action, process, and use cases. Front-loaded with the main 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?

Given the tool's simplicity (URL input, text output) and no output schema, the description sufficiently explains the result ('single text blob ready to drop at site-root/llms.txt'). Could add more about error cases or prerequisites, but still complete enough for effective use.

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

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

Schema coverage is 100% with both parameters described. The description adds extra default values (25 links) and maximum (50) for max_links, which is not in the schema, providing additional 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 uses a specific verb ('generate') and resource ('llms.txt file') and clearly states the input ('any URL'). It distinguishes from siblings by mentioning the output format and use cases like site indexing and auditing competitor AI presence.

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

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

The description explicitly lists three use cases (client site indexing, personal project drafting, competitor auditing), providing clear context for when to use. However, it does not mention when not to use or suggest alternatives, which would push to a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds explicit return fields, providing useful context beyond safety 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, front-loaded sentence with no wasted words. Lists key return fields efficiently.

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

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

For a simple fetch tool with an output schema, the description covers the essential inputs and outputs without needing error or pagination details. Complexity is low.

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

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

Schema coverage is 100% and the description reiterates the LEI code format. No additional parameter semantics beyond the schema are provided, so baseline 3 is appropriate.

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

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

The description clearly states the verb 'Fetch', the resource 'full Level 1 LEI record', and the identifier '20-character LEI code', distinguishing it from siblings like get_lei_relationships and search_lei.

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 use when a specific LEI code is known and the full record is needed. It does not explicitly exclude other tools or provide alternatives, but the 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 already declare read-only, open-world, idempotent, and non-destructive. The description adds critical behavioral context: the 'lei' parameter accepts company names, automatic resolution, and the warning about wrong LEI codes returning empty hierarchy. 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, all essential: purpose, use case, and parameter flexibility. No filler, front-loaded with the core action. Perfectly concise.

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

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

Given the presence of an output schema, the description adequately covers purpose, usage, and parameter behavior. It explains the edge case of wrong LEI codes and the name resolution feature, making it complete for a single-parameter 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?

Despite 100% schema coverage, the description adds significant value: it explains that the parameter can be a company name (not just an LEI), describes automatic resolution, and warns about the misleading empty result from a wrong-but-well-formed LEI. This goes far beyond the schema's simple type/description.

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

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

The description specifies exact verb 'Fetch', resource 'Level 2 corporate hierarchy', and lists the three relationship types (direct parent, ultimate parent, direct children). This clearly distinguishes it from sibling tools like 'lei_hierarchy_tree' or 'search_lei'.

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 'Use to map ownership trees across multinational groups.' While it doesn't list when not to use or alternatives, the context is clear and the usage scenario is well-defined, earning a 4.

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

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

Beyond the provided annotations (readOnly, idempotent, non-destructive), the description adds meaningful nuances: it specifies the GLEIF official mapping source, the output fields, the one-to-many ISIN-to-issuer relationship, and the important distinction between a valid-but-unmapped ISIN and an invalid ISIN. This is valuable behavioral context not captured by annotations.

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

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

Three sentences, fully front-loaded with the core resolution logic in the first sentence. Each subsequent sentence adds unique value (user intent, edge-case behavior) without repetition or fluff.

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

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

For a simple read-only lookup with no output schema, the description fully covers the input format, the output content (LEI, name, jurisdiction, status), the source, and edge cases (unmapped vs invalid). It also signals fidelity to external data ('mapping lags new issuance'), which is important for an open-world tool.

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

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

The schema already provides full coverage of the single 'isin' parameter (100% with type, format, and example). The description adds value by giving two concrete examples and clarifying that a structurally valid ISIN may still be unmapped, which enriches the parameter's semantics beyond the schema.

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

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

The description opens with a specific verb, 'Resolve', and clearly identifies the input (ISIN) and the output (LEI, legal name, jurisdiction, status). It explicitly frames the purpose as answering 'who issued this security', which distinguishes it from sibling tools like bic_to_lei and lei_to_isins by direction and resource.

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 intended use ('Answers who issued this security') and notes it works for non-US as well as US securities. It does not explicitly name alternatives or when-not-to-use, but the context makes the appropriate use case evident.

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 (read-only, idempotent, non-destructive), the description discloses the traversal algorithm (breadth-first over GLEIF Level 2), depth limiting, that depth is stated in the response, and that the ancestor chain is always walked to the top. These details give valuable insights into behavior without contradicting 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 two sentences, front-loaded with the primary action, and packs in necessary details like traversal method, depth handling, and alternative tool. 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?

Even without an output schema, the description explains what the response includes (ancestor chain, multi-level tree, depth stated) and provides usage examples. It is sufficiently complete for a read-only hierarchy exploration tool.

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

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

The input schema already covers 100% of parameters with clear descriptions (LEI/name and depth semantics). The tool description reinforces but does not add significant new meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool walks the full corporate ownership hierarchy, including ancestor chain and subsidiary tree. It explicitly distinguishes itself from sibling get_lei_relationships by noting when to use that alternative, 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 usage guidance: 'use get_lei_relationships instead when one hop (direct parent + direct children) is enough.' Also includes example queries that illustrate intended scenarios, giving clear context for when this tool is appropriate.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, but the description adds substantial behavioral context: it accepts either a LEI or a company name (resolved automatically and echoed back), returns a full set (bonds, share lines, ADRs) rather than a single value, and explicitly handles the empty-set case for existing entities. No annotation 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 three sentences, front-loaded with the primary action, and every sentence earns its place. It efficiently covers input flexibility, output semantics, and an edge case without redundancy or fluff.

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

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

There is no output schema, so the description carries the burden of explaining return values. It does this explicitly by stating the full-set return (bonds, share lines, ADRs) and the empty-set behavior. It also mentions the official GLEIF source, providing complete context for a single-parameter tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics beyond the schema by clarifying that the single parameter accepts both a 20-character LEI and a company name, and that names are resolved via the LEI registry and echoed back. This extra detail justifies a score above baseline.

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

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

The description clearly states the action: 'List ALL ISINs (securities) issued by a legal entity'. It uses a specific verb and resource, and identifies the scope. This distinguishes it from sibling tools like isin_to_lei (reverse direction) and get_lei (entity details), 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?

The description provides clear use cases with example queries ('what securities has this company issued' / 'all ISINs for Nestlé') and mentions the source mapping, implicitly positioning this as the forward ISIN lookup tool. It doesn't explicitly state when not to use it or name alternatives, but the context is strong enough for an agent to select it appropriately.

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, and non-destructive behavior. The description adds that it returns specific fields and is scoped to the caller's subscriptions and active subscriptions, providing useful 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?

The description is two sentences: the first states the action and return fields, the second gives usage guidance. It is front-loaded and contains no unnecessary 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's simplicity (one optional parameter, no output schema), the description covers the essential purpose, return fields, and usage scenario. It could mention limitations like pagination, but it is largely 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% with the only parameter (include_inactive) already documented in the input schema. The description does not add significant meaning beyond 'active subscriptions' implicitly referencing the parameter's effect. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists the caller's active subscriptions and specifies the return fields (id, type, params, created_at, last_fired_at, fire_count). It is distinguishable from sibling tools like subscribe and unsubscribe.

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

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

The description explicitly instructs to use this tool 'to review what you're monitoring before adding more or to find an id to cancel.' It provides clear usage context, though it does not explicitly mention when not to use it or alternatives.

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

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

Beyond the annotations (which are minimal), the description discloses behavioral details: anonymous filing returns a claim_token, how to use it later, rate limits (5/day), that it's free and doesn't count against quota, and how feedback is processed (daily digests). It also provides content guidelines (don't paste user prompts), adding significant 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 quite long but well-structured: it opens with the core purpose, then covers usage, exclusions, claim_token handling, and operational notes. Every sentence provides distinct, necessary information, though the length could be slightly trimmed without losing meaning; it's efficient but not maximally concise.

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

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

The description is comprehensive for the tool's complexity: it explains the scope (only Pipeworx tools), the anonymous claim_token flow, rate limits, quota impact, and the team's review process. Even without an output schema, users understand what to expect when filing feedback and how to follow up, making it fully complete.

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

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

The input schema already provides detailed descriptions for all parameters (100% coverage), so the baseline is 3. The description adds value by explaining the claim_token workflow with a concrete example and by advising users to describe issues in terms of Pipeworx tools/packs rather than pasting end-user prompts, which enhances message parameter semantics.

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

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

The description clearly defines the tool's purpose: telling the Pipeworx team about broken, missing, or desired functionality. It enumerates specific use cases (bug, feature/data_gap, praise) and distinguishes it from sibling tools like ask_pipeworx, which focus on questions rather than feedback.

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 (bug, feature/data_gap, praise) and when not to use it (for other MCP servers), even directing users to file issues with the appropriate alternative server. It also gives a clear criterion for identifying Pipeworx tools, providing comprehensive selection 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. Description adds behavioral context: caching (5min-1h), data source (CF analytics-engine), and that no PII is involved. This adds value 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?

Highly concise: three short paragraphs with no wasted words. Front-loaded with the core function, then use cases, then finer details. Every sentence earns its place.

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

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

For a simple one-parameter tool, the description covers output (top tools, packs, volume), caching, data source, use cases, and privacy. No output schema needed because return format is implied. Complete for its complexity.

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

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

Schema covers the single enum parameter completely. Description adds semantic guidance: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This enriches meaning beyond the schema.

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

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

The description clearly states it returns 'top tools, top packs, and total call volume' over a configurable window, distinguishing it from siblings like discover_tools or ask_pipeworx. Purpose is specific and unambiguous.

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

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

Provides three explicit use cases (discovering hot data sources, confirming canonical tools, aligning use cases). Does not mention when not to use, but given the niche nature, the guidance is sufficient.

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 goes far beyond by detailing the scanning logic (monotonicity, partition checks), semantic anchor (Jaccard similarity), partition filter (placeholder slugs), fill check (realizable vs theoretical edge), and edge cases (skipped_low_similarity, placeholders_filtered). This adds substantial behavioral 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?

The description is detailed and well-structured, front-loading the purpose and then splitting into modes. While every sentence adds value, the length is considerable and could benefit from section headers or bullet points for readability. It is appropriately sized for the complexity but slightly verbose.

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

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

Despite no output schema, the description explains the response structure in detail: opportunities[] (gap_pp, suggested_trade, reasoning, etc.) and partition_check fields including fill check. It covers use cases, edge cases, and provides enough context for an agent to understand both input and output semantics completely.

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

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

Schema coverage is 100% with both parameters described. The description adds significant meaning: explains the two modes (event and topic) with examples of acceptable inputs (slugs, full URLs), and clarifies that no args triggers a trending scan. This provides practical context beyond the schema's technical 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: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It distinguishes between three modes (no args, event, topic) and explains the specific resource and actions, differentiating it from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

The description provides explicit guidance on when to use each mode: 'Call with NO args for a trending_scan... pass event for the strongest per-event... topic for a themed cross-event scan.' It explains the rationale for cross-event scanning and suggests event mode as recommended for a specific market. However, it does not explicitly mention when to avoid this tool in favor of siblings, missing a full 'when not to use' section.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds extensive behavioral details: caching at KV level (1h keyed on knobs), response structure with by_segment and diagnostics, edge calculation details (edge_pp_net after slippage, Kelly caps, 24h move warning), and specific model logic (e.g., placeholder-slug filter, partition skip rules). This goes well beyond annotations.

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

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

The description is long (over 400 words) but justifiably so given the tool's complexity (three segments, knobs, diagnostics). It is front-loaded with purpose and well-structured with bold headings. Every sentence adds value, though some details could be more concise without losing clarity.

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

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

Despite no output schema, the description fully explains the response structure: top-level fields (by_segment, fed_candidates, _diagnostics), edge attributes (edge_pp_net, kelly_fraction), and tradeable-edge knobs. It covers caching and the rationale for excluding certain opportunities. The description is complete for an agent to use the tool effectively.

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

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

Schema coverage is 100% with all 9 parameters described in the input schema. The description adds context beyond schema: min_liquidity and max_spread_pp are labeled 'Tradeable-edge filters', min_partition_leg_kelly explains its unique per-leg behavior, and slippage_pp suggests adjustments based on fill model. This enriches parameter 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?

The description clearly states the tool scans Polymarket markets for opportunities where Pipeworx data disagrees with market price, specifically for 'what should I bet on today'. It distinguishes from siblings by detailing the three model families (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT) and tradeable-edge knobs, making its unique value clear.

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

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

The description provides explicit when-to-use guidance ('what should I bet on today') and explains how the tool avoids paging hundreds of markets. It also notes that Fed bets are surfaced but excluded from ranking, and describes how knobs like min_liquidity and max_spread_pp filter opportunities, effectively conveying usage context and alternatives.

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

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

Description extends beyond annotations by detailing response fields (tracked, expired, snapshot_dates), data sources, decay computation, and edge case handling (gaps, signed values).

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 information-dense; each sentence adds value. Could be slightly more concise, but structure is logical and front-loaded with purpose.

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

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

No output schema, but description thoroughly explains response format and data fields. Covers parameters, response details, limitations, and data freshness. Fully adequate for a complex tool.

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

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

Adds default values and clamp range for 'days', explains 'window' as snapshot family, and links parameters to response behavior. Schema coverage is 100% but description provides essential 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?

Description clearly states the tool provides edge persistence and decay telemetry from daily snapshots, answering how long an edge has existed and if it's shrinking. This distinguishes it from sibling tools like polymarket_edges (current edges) and others.

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 describes the use case: comparing fresh wide edges vs. old wide edges. Mentions limitations (TTL, snapshot gaps) but does not explicitly contrast with alternative tools for different 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?

Beyond annotations (readOnly, idempotent), description adds behavioral details: walks the order book ladder, returns verdicts (clean/degraded/cannot_fill), identifies thin legs and forced directional risk for baskets. 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?

Description is thorough but somewhat lengthy; however, all sentences add value, and front-loading with purpose aids clarity. Could be slightly more structured (e.g., bullet points) but remains efficient given complexity.

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

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

Despite no output schema, description lists all return fields and explains risk scenarios. Sufficient for agent to understand behavior and expected outputs.

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?

100% schema coverage is complemented by detailed description explaining mutual exclusivity of 'market' and 'event', default logic for 'side' in basket mode, and interpretation of 'size_usd' per mode.

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

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

The description clearly defines the tool's purpose: checking realizable vs theoretical edge against live order-book depth. It distinguishes two modes (single-market and basket) and lists specific return fields.

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: before acting on polymarket_arbitrage or polymarket_edges signals above ~$500. Warns against partial basket fills converting arb into unhedged directional position, providing clear do's and don'ts.

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, non-destructive. Description adds valuable behavioral context: compatibility_warning, temporal_alignment, skipped_cross counters, and the caveat that real spreads are rare. No contradiction with annotations.

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

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

The description is lengthy (~200 words) and dense, mixing purpose, modes, response fields, and edge cases. It is front-loaded but could benefit from more structure (e.g., bullet points) for easier scanning. Not overly verbose given complexity, but not maximally concise.

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

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

Despite no output schema, the description explains response fields and edge cases comprehensively. It covers mandatory fields (top_spreads_pp) and safety features. Could be slightly more explicit about parameter optionality, but overall complete.

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

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

Input schema covers all 3 parameters with descriptions (100% coverage). The description adds no additional parameter semantics beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool computes a cross-venue spread between Kalshi and Polymarket for the same resolving question. It distinguishes from siblings like polymarket_arbitrage by specifying 'cross-venue'. Two modes and safety fields are detailed.

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

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

The description explains when to use the tool (comparing prices across venues) and provides guidance on modes. It warns that pre-mapped topics often yield warnings, implying caution. However, it does not explicitly contrast with alternative tools like polymarket_arbitrage or state when not to use.

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

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

Annotations already declare readOnlyHint and idempotentHint; description adds scoping to identifier and dual retrieval/list behavior. No contradiction, adds 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?

Two main sentences plus a scoping/pairing sentence. Extremely concise, front-loaded with action, no wasted words. Every sentence earns its place.

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

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

For a simple retrieval tool with one optional parameter and no output schema, the description fully addresses purpose, usage, behavior, and relationships with sibling tools.

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

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

Schema coverage is 100% (baseline 3). Description restates that omitting key lists all keys, which is already in schema. Adds context of pairing with remember but no new semantic 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?

Description clearly states the tool retrieves a saved value via remember or lists all keys when the argument is omitted. It uses specific verbs and resources and distinguishes from siblings remember 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?

Provides concrete examples of when to use (looking up stored context like ticker, address, notes) and mentions pairing with remember/forget. Lacks explicit when-not-to-use or alternatives, 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 already indicate read-only, idempotent, and non-destructive behavior. The description adds details about the feed persistence, mark_read feature, and returned fields, enhancing transparency beyond annotations.

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

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

The description is two sentences long, front-loaded with the purpose, and every sentence adds value. It's structured logically: purpose, return fields, filtering options, note on polling, and alternative access.

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

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

No output schema, but the description explains returned fields. It covers filtering, polling, persistence, and an alternative endpoint. For a read-only retrieval tool, this is fairly complete, though more detail on error conditions could be added.

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 useful context for parameters like type filtering, since (ISO timestamp), and the mark_read/unread_only interaction, which 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 the tool pulls fired events from a subscription feed and returns recent alerts with specific fields like source, citation_uri, and raw payload. It distinguishes from sibling tools by focusing on the alert feed retrieval.

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

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

The description mentions 'Polls work fine' and provides an alternative URL for scripts/dashboards, giving context for usage. It does not explicitly exclude scenarios but offers practical 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 (readOnlyHint, etc.), the description discloses parallel fan-out to SEC EDGAR, GDELT→GNews fallback, USPTO soft-fail, and the return structure (grouped changes, total count, 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 longer than typical but every sentence adds value. It is front-loaded with user-oriented example queries. Could be slightly more concise, but still effective and well-structured.

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

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

All three parameters are fully described, the behavior is explained, and the output format is summarized despite no output schema. The description covers what the tool does, its sources, fallbacks, and the alternative 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%, but the description adds significant value: examples of valid values for `since` (ISO dates, relative shorthands), clarification that `type` only supports 'company', and explanation of input formats for `value` (ticker or CIK). This enriches 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's a change feed for a company, provides multiple example query patterns, and distinguishes from sibling `entity_profile`. The verb+resource combination is specific and unambiguous.

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

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

Explicitly gives example queries indicating when to use, mentions fallback behavior, explains that `entity_profile` is the alternative for static profiles, and describes the `since` parameter formats with recommended default '30d'.

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

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

Description adds behavioral details beyond annotations: persistence duration (24 hours for anonymous, permanent for authenticated), key-value pair structure, and scope by identifier. No contradiction with annotations (idempotentHint=true, destructiveHint=false, readOnlyHint=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?

Four sentences, each adding distinct value: purpose, when, how (key-value/scope), persistence/related tools. Front-loaded, 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?

For a simple memory storage tool (2 required params, no output schema), description covers all necessary context: what, when, how, persistence, and related tools. No gaps.

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

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

Schema coverage is 100% with clear parameter descriptions. Description adds example key formats but does not significantly enrich semantics beyond what schema provides. Baseline 3 is appropriate.

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

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

Description clearly states verb ('Save'), resource ('data'), and scope ('across this conversation or across sessions'). It distinguishes from sibling tools like 'recall' and 'forget' by explicitly pairing 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?

Explicitly describes when to use ('when you discover something worth carrying forward'), provides concrete examples (ticker, address, preference), notes scope ('scoped by your identifier'), and mentions alternatives ('Pair with recall...forget').

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

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

Annotations already mark the tool as readOnly, openWorld, idempotent, and non-destructive. The description adds valuable behavioral detail: cascading internal lookups, graceful degradation when GLEIF/OpenFIGI are unavailable, and structured output with label sources and an 'unresolved' list. 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 informative but verbose, especially the long sentence detailing company output identifiers and sourcing. It front-loads with examples and purpose, which is good, but the latter part could be more structured (e.g., bullet points for company vs drug). Some verbosity reduces quick readability, earning a middle score.

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 what is returned (identifiers with sources, explicit unresolved entries) and covers graceful degradation and cascading behavior. It addresses complexity well (two entity types, multiple databases). Minor gap: exact output format (JSON structure) is implied but not explicitly shown. Overall, quite complete for a tool of this complexity.

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

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

The input schema covers both parameters with 100% description coverage (type enum and value description). The description goes beyond by explaining how inputs like ISINs resolve to legal entities via GLEIF mapping, and it details the output structure for each type (e.g., CIK, ticker, LEI for companies; RxCUI for drugs). This adds significant meaning beyond the schema alone.

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

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

The description immediately states the core purpose: resolving user-spoken names to canonical identifiers needed by other tools. It provides clear examples ('What's the ticker for...', 'find the CIK for...') and distinguishes itself from siblings like get_lei or isin_to_lei by noting it performs cascading lookups that replace 2-3 manual steps, implying a composite, broader scope.

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

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

The description explicitly advises 'Use FIRST whenever you have a name but need an ID' and lists concrete query patterns. While it doesn't explicitly state when not to use (e.g., 'If you only need an LEI, use get_lei instead'), the sibling context and the tool's composite nature provide implicit guidance. The guidance is strong but could be more explicit about 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 declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds that it probes each entity with ai_visibility_check and returns rankings. No contradictions, but the behavioral context is already covered by annotations.

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

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

Three sentences, front-loaded with purpose. Every sentence adds value: purpose, use case, and output format. 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?

No output schema, but description lists return fields: score, confidence, signal density. Explanation of input usage is adequate. Could be slightly more detailed on output structure.

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

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

Schema coverage is 100%, but description adds usage context: 'entities' first treated as subject, 'models' controls which AI models to probe, 'context' disambiguates. This enriches 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?

Description clearly states 'Compare AI visibility across multiple entities side-by-side' with specific verb 'probes' and resource 'competitor AI presence'. Distinguishes from sibling 'ai_visibility_check' by focusing on multiple entities and ranking.

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 'Useful for competitive AI-marketing audits' and provides an example question. Does not explicitly state when not to use, but the context makes it clear. Contrasts with single-entity sibling 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?

Beyond annotations (readOnlyHint, idempotentHint, etc.), description discloses partial failure behavior, Bundlephobia's first measurement delay (5-30s), and lists sources_failed will indicate timeouts. 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?

Single paragraph but well-structured with purpose first, then details, then limitations. No wasted sentences. Could be slightly more concise but effective.

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

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

Given no output schema, description thoroughly explains return structure (summary block, per-advisory detail, links, alternatives) and covers edge cases like delays and fallbacks. Rich annotations complement the description.

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

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

Schema coverage is 100% with descriptions for both parameters. Description adds context: package accepts scoped packages, version defaults to latest, and explains return fields. Provides meaningful addition beyond schema.

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

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

Description clearly states the tool performs a composite check for npm packages, combining deps.dev and bundlephobia. It distinguishes from other tools by specifying npm-only scope and explicitly mentioning what it returns (summary block, advisories, links, alternatives).

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: 'whenever an agent asks is X safe / popular / small' and states that for PyPI/Maven/etc. users should use deps.dev directly. This clearly differentiates usage from 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?

Discloses matching strategy (whole-token, retry with suffix drop, word joining, fuzzy autocomplete), status field dual-role routing, country code conversion with error handling, and response always includes match_mode and searched_as. Adds value 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?

Concise yet packed with essential information. Purpose stated first, then usage and matching details. No superfluous text; 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?

Covers matching algorithm, parameter behaviors, response features, and usage context. Output schema exists (not shown) but described sufficiently. Complete for a search tool of moderate 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%, baseline 3. Description adds meaning: explains status field routing between entity and LEI status, country accepts alpha-3 and names with conversion, and query matching behavior. Exceeds schema 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?

Clearly states tool searches GLEIF LEI registry by legal entity name and returns specific fields (LEI, jurisdiction, status, cross-references). Distinguishes from siblings like get_lei (which likely gets by LEI) and resolve_entity.

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

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

Explains when to use the result (resolve canonical identity across databases) and warns about name matching limitations (abbreviations won't work). Implicitly contrasts with get_lei for direct LEI lookups, but lacks explicit when-not-to-use guidance.

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

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

Discloses embedding model (BGE-base-en), windowing (500-char overlapping), and character cap (200K chars with truncation flag). These details are beyond annotations (readOnlyHint, idempotentHint), which already indicate safety. 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?

Single paragraph front-loads core purpose and then adds details efficiently. Every sentence adds value; could benefit from slight structural separation but remains clear and non-redundant.

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

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

Given three parameters, full schema coverage, and no output schema, the description provides sufficient context: embedding details, truncation behavior, and workflow integration. Missing return format or offset description, but functionality is well-specified.

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 (100% coverage). Description adds examples for query and clarifies limits (max ~200K chars, 1-20 limit), but does not significantly extend beyond 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?

Clearly states 'Semantic search INSIDE a fetched record' and gives concrete examples (SEC 10-K, article) of input types. Explicitly distinguishes from sibling tools like ask_pipeworx_grounded by explaining their relationship.

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

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

Explicitly says 'Use when the record is too big to cram into the prompt' and describes ideal scenarios. Mentions pairing with ask_pipeworx_grounded as an alternative workflow, but does not explicitly list 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 mutation and idempotency. The description adds critical context: requires OAuth account, returns subscription ID, webhook secret is one-time, auto-disable after failures, and SMS rate limits. 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 well-structured with front-loaded purpose and prerequisites, followed by type-specific and delivery details. 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?

For a subscription creation tool with 3 params (nested objects), no output schema, the description covers type-specific filters, delivery options, prerequisites, and behavior (e.g., webhook secret retrieval, auto-disable). It is thorough and leaves no ambiguity.

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

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

Schema coverage is 100%, but the description enriches each parameter with concrete examples and additional constraints (e.g., 'sponsor or condition required' for clinical_trial, webhook signing details). This adds significant meaning beyond the schema.

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

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

The description explicitly states 'Create a proactive monitoring subscription to a live-data event stream' and specifies the resource and return value. It distinguishes from siblings like list_subscriptions and unsubscribe by focusing on creation.

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

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

The description provides clear context for when to use (setting up monitoring), prerequisites (Pipeworx OAuth account), limitations (not for anonymous/BYO), and details on delivery channels with constraints (SMS cap, phone verification).

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

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

Annotations already indicate safety (readOnly, idempotent, non-destructive). The description adds value by specifying the return format (category-bucketed examples with tool+argument shape) and that it uses the live catalog. 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 informative and front-loaded with aliases. Every sentence adds value, though it could be slightly more concise without losing clarity.

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

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

Given the lack of output schema, the description fully explains the return value (category-bucketed questions with exact tool+argument shape) and the use case. It covers all needed context for an agent to select and invoke this tool correctly.

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

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

Schema coverage is 100%, but the description significantly enriches the topic parameter by listing concrete example values and explaining behavior when omitted (full spread). This adds meaning beyond schema definitions.

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: onboarding entry point that returns category-bucketed example questions. It distinguishes itself from siblings like ask_pipeworx by positioning itself as the first tool to use when exploring capabilities.

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 FIRST' and provides when-not-to-use guidance by directing to alternatives like ask_pipeworx, entity_profile, etc. Also clarifies when to pass the optional topic parameter.

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

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

The description discloses that the operation is a deactivation, not deletion, and that historical events remain available. This adds context beyond the annotations, which indicate it is not destructive and is idempotent.

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

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

The description is two sentences long, front-loaded with the main action, and contains every sentence with value. No wasted words.

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

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

For a simple tool with one parameter and no output schema, the description is complete. It explains the behavioral effect, constraints, and relation to other tools like recent_alerts.

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

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

Schema coverage is 100% and the description briefly mentions 'by id', but it does not add significant meaning beyond the schema's description of the id parameter. 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 cancels a subscription by id, using a specific verb and resource. 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?

It explains ownership enforcement (you can only cancel your own subscriptions) and the deactivation behavior. While it doesn't explicitly name alternatives, the context is sufficient for deciding when 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 well beyond the annotations (readOnlyHint, openWorldHint, idempotentHint) by explaining verdict types, the structured vs. grounded pipeline behavior, and the crucial caveat that 'could_not_verify' is not evidence for or against the claim and carries verification_error{stage,detail}. It also clarifies 'unsupported' semantics. This adds rich behavioral context that annotations cannot convey.

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

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

The description is front-loaded with example user phrasings and clearly structured into purpose, usage, pipeline details, return values, and caveats. It is somewhat verbose due to the many example phrases, but every sentence contributes useful information, so it earns a 4 rather than below.

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 verification paths, multiple verdicts, error semantics) and no output schema, the description is exceptionally complete. It explains the return format (verdict, actual value with citation, reasoning), the meaning of each verdict type, and the behavior of both pipelines. No critical information is missing.

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

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

Schema description coverage is 100%, with both claim and tolerance_pct already well-documented. The tool description adds general process context (e.g., 'exact percent-delta math') but does not add any new parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description uses specific verbs and resources: 'natural-language claim verification against authoritative sources' and 'fact check' / 'verify the claim that…', making it unmistakable what the tool does. It also distinguishes from siblings by specifying the two verification paths (SEC EDGAR/XBRL for financial claims vs. grounded pipeline for other claims), which other tools like ask_pipeworx_grounded may not cover.

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

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

The description gives explicit when-to-use guidance: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also describes when financial vs. non-financial paths apply and notes that it 'replaces 4–6 sequential calls,' implicitly advising to use this tool instead of chaining multiple lookups. This is clear and actionable.

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