Riksbank Se

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

Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds behavioral detail: default model (free), optional Anthropic with BYO key, cost implications, output structure with per-model fields. No contradiction with annotations.

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

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

Two concise sentences; front-loaded with core functionality; no redundant words. Efficient and clear.

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

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

No output schema but description summarizes return structure. All parameters documented; context hints provided. Complete for a moderate-complexity tool with good annotations.

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

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

Schema covers all 4 parameters with descriptions (100% coverage). Description adds usage context (default model, key requirement) but does not fundamentally extend meaning beyond schema. Baseline 3 is appropriate.

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

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

Description uses specific verb 'probe' and resource 'LLMs' to state it scores visibility per model. Clearly distinguishes from sibling tools like ask_pipeworx which are for general Q&A. Specifies output format.

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 cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Does not mention when not to use or alternatives among siblings, but context is clear.

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

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

Annotations declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavior beyond these: the tool 'fills arguments' automatically, returns 'structured answer with stable pipeworx:// citation URIs', is 'one fast call', and 'works on every tier'. It doesn't go into response format details, but given no output schema exists, this is strong supplemental 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?

Front-loaded with the most critical directive ('PREFER OVER WEB SEARCH'), followed by concrete use cases, examples, and finally escalation paths. While lengthy at ~180 words, every sentence earns its place given the tool's central routing role. The structure (use cases → examples → when-to-escalate) is logical and scannable, even if a trim of some duplicate example patterns could tighten it further.

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

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

For a tool of this complexity — a universal router across thousands of sources — the description covers all critical angles: what it routes, how it behaves (fills args, returns citation URIs), performance characteristics ('one fast call'), tier availability ('works on every tier'), and when to use alternatives. The rich examples (from unemployment rates to GLP-1 trials) disambiguate edge cases effectively. The absence of an output schema makes the description's job more important, and it delivers.

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 all six parameters (question plus five aliases) documented and examples provided in the schema's 'examples' field. The description adds the key semantic insight that the tool 'fills arguments' itself, meaning the agent need not pre-structure inputs. The schema examples showing 'What was Apple's revenue in 2024?' further cement the natural-language-query expectation.

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

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

The description uses specific verbs ('Routes', 'returns') and precisely scopes the resource: 5,566 tools across 1,462 sources covering SEC filings, FDA data, FRED/BLS stats, and more. It clearly differentiates from siblings by naming ask_pipeworx_grounded and deep_research as escalation paths. The 'START HERE for most questions' framing cements its role as the default entry point.

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

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

Explicit when-to-use guidance is front and center: 'PREFER OVER WEB SEARCH for questions about current or historical data' with a concrete list. It provides explicit alternatives ('for a hallucination-resistant single answer... use ask_pipeworx_grounded; for a broad/multi-part question... use deep_research') and clear exclusion criteria ('Step up only when needed'). This is exemplary usage guidance.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable context about its experimental nature, that no candidate is currently active, and that it currently matches ask_pipeworx exactly, enriching behavioral understanding 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 efficiently structured in four sentences, each serving a distinct purpose: defining the tool, stating current state, providing usage instruction, and reassuring it is a full router. There is no superfluous content; 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?

Given the simple parameter schema and the annotations covering safety, the description is complete enough for effective use. It specifies the response shape matches ask_pipeworx, clarifies the experimental edge, and reassures it is fully functional. It could be slightly more explicit about output format, but this is adequately covered by reference to ask_pipeworx.

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

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

The input schema already documents all parameters with 100% coverage, including aliases and descriptions. The tool description does not add any additional parameter semantics, relying on the schema's complete documentation. Thus a 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 is a beta version of ask_pipeworx, an identical universal router routing to 5,566 tools, with experimental routing improvements. It explicitly distinguishes itself from the stable ask_pipeworx and mentions the same arguments and response shape, making its purpose unambiguous and differentiated.

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

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

It gives explicit usage guidance: 'Use it exactly like ask_pipeworx when you want the newest routing' and contrasts with the stable router, indicating when to prefer this beta version. It also clarifies that it is a full working router, not a fallback, and explains the comparison process for deciding merges.

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

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

Annotations already declare readOnlyHint and idempotentHint, but the description goes further by detailing the exact response structure, the refusal reason enum, and the constraint of using 'ONLY what the tool result contains.' It also discloses the additional LLM call, enhancing transparency beyond the structured metadata.

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

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

The description is compact yet information-dense, front-loading the key concept ('Hallucination-resistant') and then efficiently covering routing, extraction, output, usage, and cost. Every sentence contributes actionable value without redundancy.

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

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

Despite lacking an output schema, the description fully specifies the return value structure and refusal cases, covering the tool's operation, limitations, and appropriate contexts. It leaves no notable gaps given the tool's 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?

The input schema has 100% coverage for its single meaningful parameter 'question' with aliases documented in the schema itself. The description adds no extra parameter details, so the baseline of 3 is appropriate since the schema fully anticipates the information.

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

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

The description clearly states the tool is a 'Hallucination-resistant answer mode for high-stakes reads' that extracts answers using only tool result content. It differentiates itself from siblings like ask_pipeworx by highlighting the refusal mechanism and return format, making its purpose unmistakable.

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

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

Explicitly instructs to 'Use whenever an answer will be quoted, cited, or acted on' and advises to 'prefer ask_pipeworx for casual lookups,' providing clear when-to-use and when-not-to-use guidance. It also mentions the extra LLM call cost, helping with cost-aware decisions.

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?

Extensively details behavior: fan-out, response shapes, resolver contract, parent event extraction, news fallback, safety modes for low-confidence and closed markets, spread warnings, cancellation rule parsing. Complements annotations (readOnly, idempotent) with rich 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?

Very detailed and structured, but lengthy (over 500 words). Sections help readability, but could be more concise; front-loading is acceptable with first sentence stating 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 no output schema, description covers all response fields, edge cases (closed markets, low confidence, illiquidity, cancellation rules), and error paths. Extremely thorough.

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 fully explained: market (slug/URL/text), depth (quick/thorough), include_raw (default false, size implications). Schema already covers them, but description adds practical guidance and defaults.

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

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

Clearly states the tool researches Polymarket bets by pulling Pipeworx data, with specific verbs and resource description. Distinguishes from sibling tools like polymarket_edges and polymarket_arbitrage by focusing on research and data gathering.

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

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

Explicit use cases given: 'should I bet on X', etc. Provides examples of fan-out and classifiers. 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, open-world, idempotent, and non-destructive behavior. The description adds specific details about which financial metrics are pulled (revenue, net income, cash, debt) and drug data sources, 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 comprehensive but slightly verbose. However, every sentence adds value and is front-loaded with example queries. It is well-structured with clear sections for company and drug.

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

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

Despite lacking an output schema, the description mentions return format (paired data with citation URIs) and covers all relevant details: input constraints, data sources, sorting behavior, and performance benefits.

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 informative descriptions. The description further explains what each entity type returns and how fiscal years are handled for companies, providing concrete examples that add significant meaning.

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

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

The description clearly states the tool performs side-by-side comparisons of 2–5 companies or drugs. It provides example queries and explicitly distinguishes itself from sequential lookups, making the purpose unmistakable.

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

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

The description advises 'ALWAYS PREFER over sequential single-pack lookups' and notes it replaces 8–15 sequential lookups, guiding the agent to use this tool for comparisons and avoid less efficient alternatives.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint as true and destructiveHint as false. The description additionally discloses the mathematical operation (series1/series2 per day), the date range handling (omit to for latest), and the source of series IDs (SEK fixings ending in 'PMI'). 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 two sentences plus an example, front-loaded with the core purpose. Every sentence adds meaningful information without redundancy. The example is illustrative and reinforces the parameter semantics.

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 read-only computational tool with no output schema, the description adequately explains the return value (series1/series2 per day), covers all parameters (required and optional), and provides a concrete example. No additional context is needed for correct invocation.

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

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

Schema coverage is 100%, providing descriptions for all four parameters. The description adds value beyond the schema by explaining the relationship between series1 and series2 (base vs quote), the derived result formula, and the effect of omitting the to parameter. The example further clarifies parameter usage.

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 cross exchange rates between two SEK currency-fixing series, specifying series1 as base and series2 as quote, with the result being series1/series2 per day. It includes a concrete example (EUR/USD derived from SEK fixings) and distinguishes itself from the sibling tool list_series by referencing it for finding series IDs.

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

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

The description advises using SEK currency series IDs ending in 'PMI' and directs users to list_series for finding available series. It explains the optional to parameter and default behavior (run through latest date if omitted). However, it does not explicitly state when not to use this tool or mention alternatives beyond list_series.

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, openWorldHint, idempotentHint, and non-destructive. The description adds significant context: requires account, depth tiers (thorough paid), one-call decomposition, parallelism, returns missing data as gaps[], never invents, includes contradictions[], and semantic excerpting. It also provides expected latency (15-90s). Minor gap: it doesn't explicitly discuss the broad scope of the open-world nature, but annotations already cover that.

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 information-rich, but it is quite long (multiple sentences with many clauses) and front-loads requirements (account) rather than starting with the core purpose. It could be restructured for quicker scanning, but every sentence adds meaningful information. It earns a 3 because while thorough, it lacks tight organization.

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 high complexity (parallel routing, multiple depth levels, structured output with gaps and contradictions), the description is exceptionally complete. It covers input, behavior, output characteristics (findings packet, citations, gaps), limitations (what it can't do), and performance expectations. There is no output schema, so the description fully compensates for that. Without this description, the agent would be lost.

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

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

Schema coverage is 100% (both parameters documented). The description adds semantics beyond the schema by explaining the meaning of depth levels ('quick'=3 facets, 'standard'=gap recovery, 'thorough'=paid with iterative hop and contradictions). It also clarifies that the question can be broad/multi-part, which enhances the schema's natural language description. This adds value over the schema alone.

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

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

The description clearly states the tool's purpose: grounded multi-source research across Pipeworx's structured data sources, with explicit mention of the scope (1462 sources) and the decomposition/parallelization approach. It distinguishes itself from siblings by explicitly contrasting with ask_pipeworx and open-web search, and provides concrete example use cases.

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

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

The description provides explicit when-to-use guidance: best for broad/multi-part structured questions, and when-not-to-use: for breaking/current news or single lookups, prefer ask_pipeworx. It also mentions prerequisites (account sign-in) and alternatives (ask_pipeworx). This is exemplary 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 indicate readOnly and idempotent, but the description adds valuable behavioral details: returns 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples)' and that results are 'ready to call directly, no second schema lookup needed.' 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?

Front-loaded with the core purpose and usage. Every sentence contributes: purpose, usage context, output description, and strategic advice. Could be slightly more terse but is well-organized for an AI agent.

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

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

Given no output schema, the description fully explains what the tool returns: tool names, descriptions, full input schemas with examples. It also covers the primary parameter and its aliases. Nothing missing for a discovery tool.

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

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

Schema coverage is 100% (baseline 3). The description adds meaning by explaining aliases and giving concrete examples of natural language queries. It reinforces that 'query' is the primary parameter without duplicating schema JSON structure.

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?

Explicitly states 'Find tools by describing the data or task' with clear verb-resource pairing, lists dozens of domains, and distinguishes from sibling tools by advising 'Call this FIRST when you have many tools available.'

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

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

Provides explicit usage context ('Use when you need to browse, search, look up, or discover what tools exist for:'), lists specific domains, and includes a when-not hint ('not just one answer') and strategy ('Call this 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, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: it fans out across multiple sources, details exact return fields (cik, recent_filings with URIs, fundamentals, patents with sunset note, news via fallback, LEI), and discloses limitations (patents API sunset). 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 a single paragraph but is well-structured: it front-loads example queries, states the core purpose, then details the fan-out and return fields. While dense, every sentence adds value. Minor room for improvement in readability (e.g., bullet points), but overall 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 2 parameters, 100% schema coverage, and no output schema, the description comprehensively explains what the tool returns (cik, recent_filings with URIs, fundamentals sorted by period, patents status, news fallback, LEI). It also covers limitations (patents sunset, name not supported), making it complete for an agent to 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%, and the description adds meaning beyond the schema: 'value' explains that names are not supported and recommends resolve_entity, and gives examples (ticker or CIK); 'type' clarifies that only 'company' is supported currently. This helps agents understand parameter usage beyond enum constraints.

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 as providing a 'full cross-source profile of a US public company in ONE parallel call.' It uses specific verbs ('profile') and resources ('US public company'), and distinguishes itself from chaining individual lookups, thus setting clear expectations.

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 when to use ('Tell me about X', 'research Acme', etc.) and when not to (names not supported, use resolve_entity first). It also contrasts with alternative approaches (chaining single-pack lookups), providing strong usage guidance.

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

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

Annotations already indicate destructive and idempotent; description adds context about clearing sensitive data, enhancing transparency beyond defaults.

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

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

Two sentences, front-loaded with purpose, no wasted words, very efficient.

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

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

Simplicity of tool (single param, no output schema) combined with annotations makes description fully adequate for correct invocation and usage context.

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

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

Schema coverage is 100% and parameter description is clear; description adds no extra semantic value beyond schema.

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

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

Clear verb (Delete), resource (memory), and method (by key). Explicitly distinguishes from siblings 'remember' and 'recall'.

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

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

Explicit when to use (stale context, task done, clear sensitive data). Mentions pairing with 'remember' and 'recall' but lacks explicit 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 the tool as read-only, idempotent, and non-destructive. The description adds behavioral details: fetches page, extracts title/description/key links, emits markdown format. This adds context 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 concise (two sentences plus a short list), front-loaded with the core action, and well-structured. No unnecessary words, but could be slightly sharper. Still earns a 4.

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

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

The tool is simple with good annotations and no output schema needed. The description covers input, output format, and use cases. It is complete enough for an agent, though error handling is not mentioned. Score 4.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description reiterates the purpose but does not add meaningful semantics beyond the schema. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool generates an llms.txt file for any URL, specifying the verb 'generate' and resource 'llms.txt file'. It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on file generation rather than scanning or analysis.

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

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

The description provides explicit use cases: getting a client's site indexed, drafting for own project, auditing competitor AI crawler view. It does not explicitly state when not to use or name alternatives, but the context is clear enough for basic decision-making.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the description does not need to repeat safety. It adds that the tool returns 'an array of {date, value}', which clarifies the return format. It also provides example series IDs and their meanings (e.g., EUR/SEK fixing, policy rate). It does not mention any limits, pagination, or error behavior, but the annotations cover the core behavioral traits. The description 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?

The description is three sentences: purpose, parameter details, and example plus hint. Every sentence earns its place. It is front-loaded with the core function, then adds specifics. No filler. The structure is optimal for quick parsing by an AI agent.

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

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

Given the tool's simplicity (3 required parameters, no output schema, read-only), the description covers all essential aspects: what it does, parameters with format, return shape, examples, and a pointer to a sibling for discovery. No empty spaces remain that would hinder correct invocation. The description is self-contained and actionable.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds meaning by specifying date format (YYYY-MM-DD), providing real series ID examples (SEKEURPMI, SECBREPOEFF) with their economic context, and showcasing a use case. It also includes an example JSON snippet in the schema. This enriches the agent's understanding beyond the schema's property 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 verb 'get' and resource 'time-series observations for one series over a date range'. It specifies parameters (series ID, from/to) and includes concrete examples (SEKEURPMI, SECBREPOEFF). It distinguishes from sibling tool list_series by advising its use for series discovery, and implicitly from latest_observation by focusing on a date range. The purpose is unambiguous and actionable.

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

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

The description explains when to use this tool: for a single series over a date range. It mentions companion tool list_series for discovering IDs. However, it does not explicitly state when NOT to use it (e.g., for multiple series or latest observation only). There are siblings like latest_observation and cross_rates that could serve similar needs, but no direct comparison is given. The guidance is helpful but lacks 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 (readOnlyHint, idempotentHint) already mark it as safe. The description adds return format {date, value} and concrete examples, providing context beyond annotations. No contradictions.

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

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

Two sentences plus examples, front-loaded with purpose. No wasted words, efficient and clear.

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

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

For a simple tool with one parameter and no output schema, the description fully covers what it does, return structure, and parameter usage. Combined with annotations, it is complete.

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

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

The single parameter 'seriesId' has full schema coverage. The description enriches it with examples and their real-world meaning (e.g., policy rate, exchange rate), helping the agent choose meaningful values.

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

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

The description explicitly states it returns the most recent observation for a single series as {date, value}. Examples with specific series IDs clarify its function. It is distinct from sibling tool 'get_observations' which likely returns multiple observations.

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 single latest observation is needed, but it does not directly compare to alternatives like 'get_observations' nor provide 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?

Annotations already declare readOnly, idempotent, openWorld. Description adds substantive behavioral details: case-insensitive substring matching, return content, and the fact that omitting query returns full list. This goes beyond annotations without contradicting them.

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

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

Description is concise (5 sentences), front-loaded with core purpose, then expands with filtering details and examples. No redundant or missing information; every sentence serves a clear function.

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

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

Given the tool's simplicity (2 optional params, no output schema, read-only annotations), the description covers all necessary aspects: purpose, result contents, filtering behavior, and practical examples. An agent has sufficient information to use 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?

Although schema covers both parameters (100% coverage), description adds significant practical value: examples of query values ('policy', 'EUR'), lists well-known series IDs, explains default behavior (list all ~117 series). This is exactly the kind of enrichment that helps an agent select correct parameter values.

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

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

Description clearly states verb 'Browse/search' and specific resource 'Riksbank SWEA catalogue of time series'. It details what is returned (series IDs, descriptions, date ranges) and provides concrete examples of well-known series, 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?

Description implies usage: for finding and filtering series. Provides examples of useful queries and notes omitting query lists all. Does not explicitly contrast with sibling tools like 'get_observations' or 'latest_observation', but context is clear enough for an agent to infer 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds context about scope (caller's subscriptions) and returned fields, but does not contradict the annotations.

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

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

Three sentences with no wasted words. Purpose and usage are front-loaded for quick comprehension.

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, combined with the schema and annotations, provides all necessary information: purpose, scope, return fields, usage context, and parameter behavior. No output schema is needed.

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

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

Schema coverage is 100% with parameter 'include_inactive' well-documented. The description does not add further parameter details, so baseline score is appropriate.

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

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

The description clearly states it lists the caller's active subscriptions and specifies the returned fields (id, type, params, timestamps, fire_count). This distinguishes it from siblings 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 advises using this tool before adding new subscriptions or finding an id to cancel. It implies alternatives (subscribe, unsubscribe) but doesn't name them explicitly.

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 key behavioral traits beyond annotations, including the claim_token flow: 'Filing without an account returns a `claim_token`; pass it back later as pipeworx_feedback({claim_token:"pwfb_…"}) to read whether it was fixed and what changed.' It also states rate limits ('Rate-limited to 5 per identifier per day') and that it's free. This is rich, non-obvious 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?

Every sentence earns its place: purpose, use cases, exclusions, claim_token instructions, rate limits, and cost. The description is front-loaded with the core action, then expands with essential details. No fluff or repetition.

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

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

Given there is no output schema, the description adequately explains the key return behavior (claim_token and later status check). It also covers rate limits, cost, and the type of feedback expected. The tool is a feedback submission, and the description covers all necessary facets for correct invocation.

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

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

The schema already covers all parameters with descriptions (100% coverage), so baseline is 3. The description adds extra semantics by advising 'don't paste the end-user's prompt' and 'Describe the issue in terms of Pipeworx tools/packs,' which clarifies message content. It also reinforces the claim_token usage pattern, though the schema already handles that. This added guidance warrants a 4.

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

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

The description clearly states the tool's purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It names the specific resource (Pipeworx tools served by this connection) and distinguishes itself from sibling tools by noting it's only for tools from this connection, making the purpose unmistakable.

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

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

Explicitly provides when-to-use criteria: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a clear exclusion: 'if the tool came from a different MCP server... file it with that server instead.' This goes beyond vague context to actionable decision 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 indicate read-only, open-world, idempotent, non-destructive. Description adds value: data source (CF analytics-engine), privacy (no PII), caching (5min-1h). 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?

Extremely concise and well-structured: one-line summary, then bullet points for use cases, then technical details. 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?

For a simple tool with one optional parameter and no output schema, the description fully covers input, output, use cases, and caching. Nothing missing.

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

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

Schema coverage is 100% with a clear enum description. The description adds semantic context about window behavior (short vs. long windows surface different trends), enhancing 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 verb 'returns' and the specific resources: top tools, top packs, and total call volume over a window. It distinguishes itself from sibling tools like discover_tools by focusing on trending usage.

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 concrete use cases for when to use this tool (e.g., discovering hot data sources, confirming canonical tool). Lacks explicit 'when not to use', but context is clear.

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

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

Annotations declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false. The description adds behavioral context: internal workings (monotonicity checks, partition checks), live data interaction, filtering via Jaccard similarity and placeholder fractions, and fill-check pricing analysis. There is no contradiction with annotations.

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

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

The description is long but every sentence adds value. It is logically structured: first line summary, then mode explanations, technical details, and response format. It is front-loaded with the purpose and avoids redundancy.

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

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

Despite no output schema, the description thoroughly covers the response structure including opportunities array, gap_pp, suggested_trade, reasoning, monotonicity context, partition check fields, and fill check details. It also explains edge cases like skipped_low_similarity and placeholder filtering, making it fully actionable.

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

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

Schema coverage is 100%, yet the description adds significant value: explains that 'event' takes a slug or Polymarket URL, 'topic' takes a seed question, and both parameters are optional. It provides examples and details on how each parameter changes behavior, going beyond the schema's basic type/format.

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

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

The description explicitly states the tool finds arbitrage opportunities via monotonicity violations and partition-sum checks, clearly distinguishing it from sibling tools like polymarket_edges or polymarket_fill_risk. The three modes (no args, event, topic) are clearly defined with specific use cases.

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

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

The description provides explicit guidance on when to use each mode: 'Call with NO args' for trending scan, 'event (recommended for a specific market)', and 'topic (for cross-event scanning)'. It also warns against trading when realizable edge is ≤0 and directs to polymarket_fill_risk for custom sizing.

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 readOnlyHint and idempotentHint annotations, the description discloses caching behavior (1h KV cache), diagnostic outputs when segments are empty, edge calculation net of slippage, Kelly fractions, and a 24h move warning. This adds 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 detailed but front-loaded with the core purpose. While slightly verbose, every sentence adds value. A more structured format (e.g., bullets) could improve readability, but it remains efficient.

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

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

Given 9 parameters, 100% schema coverage, no output schema, and complex outputs, the description fully explains the three response segments, tradeable-edge knobs, diagnostics, and caching. It 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%, but the description enhances every parameter with practical usage context, e.g., slippage_pp includes guidance on typical execution costs and min_partition_leg_kelly explains why min_kelly does not apply to partition arbs.

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 scans Polymarket markets for opportunities where Pipeworx data disagrees with market price. It is built for 'what should I bet on today' and distinguishes itself from siblings like polymarket_arbitrage and polymarket_edge_tracker by its specific method and segmentation.

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

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

The description provides clear context on when to use the tool ('what should I bet on today') and details the tradeable-edge knobs for filtering. However, it does not explicitly exclude other sibling tools or provide when-not guidance.

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

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

Annotations already indicate readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds substantial behavioral context beyond annotations: it details response structure (tracked[], expired[], snapshot_dates[]), decay calculation (based on |edge_pp_net|, signed by direction), and limitations (60-day TTL, not intraday). This is highly transparent.

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

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

The description is long but well-structured: it front-loads the core question, unpacks response fields, and ends with limitations. Every sentence adds value, and the length is justified given the complexity. No redundancy.

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

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

Given the complexity (time-series, decay, expiration) and absence of an output schema, the description compensates by thoroughly explaining the response fields and limitations. It covers all necessary aspects for an agent to understand input, output, and caveats.

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

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

Schema coverage is 100%, so baseline is 3. The description adds some context (e.g., days lookback clamp 2-30, window family options) but largely mirrors the schema. It provides additional context on when snapshots are written (cache-miss), but does not significantly enhance parameter understanding beyond the schema.

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

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

The description clearly states the tool's purpose: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots. Answers how long has this edge existed and is it shrinking?' It uses a specific verb ('answers'/'provides telemetry') and resource ('edge persistence/decay'), and distinguishes itself from siblings by focusing on time-series and decay rather than just current edges.

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

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

The description provides explicit context on when to use the tool, such as contrasting fresh wide edges with 3-week-old wide edges. However, it does not explicitly state when NOT to use the tool or name alternative tools. The usage context is clear but lacks exclusionary 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 rich behavioral detail: it walks the ladder, returns top_of_book, vwap_fill_price, slippage, shares_filled, verdict, and warns about forced_directional_risk. No contradiction with annotations.

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

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

The description is long but well-structured with clear sections (single-market, basket). It front-loads the main purpose and requirement. Every sentence contributes needed information for correct usage, though it could be slightly condensed 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?

No output schema exists, yet the description thoroughly explains return values for both modes (top_of_book, vwap, slippage, shares_filled, verdict, etc.), includes edge case warnings (thin_legs, max_clean_notional, forced_directional_risk), and covers error conditions (cannot_fill). Extremely complete.

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

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

Schema description coverage is 100% (all 4 parameters described). The description adds context beyond the schema, such as explaining size_usd as spending vs target proceeds, side default logic for basket mode, and the 'clamp 10–1,000,000' for size_usd. This adds meaningful nuance.

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

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

The description clearly states it performs a 'realizable-vs-theoretical edge check against live CLOB order-book depth', distinguishes between single-market and basket modes, and specifies the output. It is highly specific and differentiates from siblings like polymarket_arbitrage and polymarket_edges.

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

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

Explicitly states requirement of one of market or event, provides explicit when-to-use guidance ('before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'), and explains why (theoretical overround not capturable, partial basket fills convert arb to unhedged directional).

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint true, destructiveHint false. The description adds significant behavioral context: compatibility_warning conditions (non-equivalent bet shapes, semantically unrelated events), temporal_alignment flag, and skipped_cross_type/subtype counters. It explains that real cross-venue spreads are rarer than suggested. No contradiction with annotations.

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

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

The description is well-structured with sections for modes, response, and safety fields, making it easy to scan. However, it is relatively long and includes some explanatory detail that could be slightly condensed without losing clarity. Still, every sentence serves a purpose, so it earns a 4 rather than a 3.

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 venues, two modes, safety fields) and the lack of an output schema, the description provides a thorough explanation of return values (leg-by-leg prices, top_spreads_pp) and safety fields (compatibility_warning, temporal_alignment, skipped counters). An agent can fully understand the tool's behavior and output without additional context.

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

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

Schema description coverage is 100% (all three parameters described). The description adds value beyond the schema by listing the 10 pre-mapped topic shortcuts, explaining that kalshi_event_ticker and polymarket_event_slug override topic-mapped sides, and providing examples in the input schema. This enriches the agent's understanding of parameter usage.

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 computes cross-venue spread between Kalshi and Polymarket for the same resolving question. It specifies two modes (topic shortcuts and explicit tickers) and describes the output (leg-by-leg prices and top spreads). This distinguishes it from sibling tools like polymarket_arbitrage, which focuses on single-venue arbitrage.

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

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

The description explicitly says when to use each mode: topic for pre-mapped macros, explicit for custom pairings. It warns that most pre-mapped topics return compatibility_warning, so they are not automatically tradeable. It explains when spreads are meaningful (equivalent bet shapes) and when they are not (compatibility_warning fires). This provides clear guidance on when to trust the output.

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. The description adds behavioral context about scoping to identifier and pairing with sibling tools, providing value 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?

Two sentences, front-loaded with purpose and key behavior. No unnecessary words; every sentence serves a 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?

The description is complete for a retrieval tool with a single optional parameter. It covers behavior, scoping, and pairing with sibling tools, leaving no ambiguity despite the absence of an output schema.

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

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

Schema coverage is 100% and includes a clear parameter description. The description adds semantics by explaining that omitting the key lists all keys, which is not in the schema examples. This adds modest additional value.

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

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

The description clearly states the tool retrieves a value saved via remember or lists all saved keys when no argument is given. It distinguishes itself from sibling tools remember and forget by specifying 'retrieve' and 'list' actions.

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 (look up context stored earlier) and when to omit the key argument (list all keys). It mentions pairing with remember and forget, offering clear context for usage.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) already indicate safe, non-destructive behavior. The description adds valuable behavioral details: returns most recent events, mark_read flagging behavior, polling support, and the nature of returned data (source, citation_uri, raw payload). No contradictions.

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

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

The description is three sentences, front-loaded with the core action, and every sentence adds value. It efficiently covers purpose, key features, and an alternative access method without unnecessary detail.

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

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

Despite having no output schema, the description explains return fields (source, citation_uri, raw event payload) and mentions the limit parameter's range (1-200). Given the tool's simplicity and the rich annotations, the description provides complete contextual information 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?

All 5 parameters are fully described in the input schema (100% coverage). The description adds functional context (e.g., 'Filter by type and/or since', 'Set mark_read:true to flag returned events read', 'Polls work fine') that aids understanding beyond the schema fields.

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

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

The description clearly states the tool's purpose: 'Pull fired events from your subscription feed.' It specifies what data is returned (source, citation_uri, raw event payload) and provides filtering options. This distinguishes it from related tools like list_subscriptions or subscribe.

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 and provides context: filtering by type and since, setting mark_read, and polling suitability. It also mentions an alternative HTTP endpoint for scripts/dashboards. However, it does not explicitly contrast with sibling tools 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, openWorldHint, idempotentHint, and destructiveHint. The description adds detailed behavioral context: it fans out to multiple sources (SEC EDGAR, GDELT→GNews, USPTO), explains the fallback mechanism, and notes the PatentsView API sunset causing soft-fail. This goes well beyond the annotations.

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

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

The description is fairly long but every sentence contributes useful information. It is well-structured: starts with examples, then describes functionality, parameter behavior, source details, fallbacks, and alternative tool. It could be slightly more succinct without losing clarity, but it remains efficient.

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

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

Given the tool's complexity (multiple data sources, fallback, parameter parsing, no output schema), the description is complete. It explains the return format: 'structured changes[] grouped by source + total_changes count + pipeworx:// citation URIs'. It also addresses edge cases like the PatentsView API sunset. No gaps remain.

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

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

Schema coverage is 100% with descriptions on all three parameters. The description adds significant meaning: explains `since` accepts ISO dates or relative shorthand ('7d', '30d', '3m', '1y') and suggests '30d' or '1m' for typical monitoring; clarifies `value` can be ticker or CIK; and restates that `type` is only 'company'. This adds value beyond the schema.

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

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

The description starts with concrete example queries ('What's new with X', 'latest on Y') and explicitly states it is a 'change feed for a company in the last N days/weeks/months'. It clearly distinguishes from the sibling tool 'entity_profile' by specifying when to use the alternative. This is a specific verb+resource with sibling differentiation.

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

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

The description provides explicit guidance: 'Use entity_profile instead when you want the static profile'. It also explains the fallback behavior (GDELT preferred, GNews when rate-limited or 5xx) and notes that USPTO soft-fails until reactivated. This clearly informs when and how to use the tool.

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

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

Annotations indicate a write operation (readOnlyHint=false) and idempotency (idempotentHint=true). The description adds behavioral context: key-value scoping by identifier, persistence duration for authenticated vs anonymous users, which goes beyond annotations. No contradictions.

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

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

The description is efficiently structured: main purpose first, then usage guidance, then technical details. Every sentence adds value with no redundancy.

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

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

While the description covers primary use and persistence, it lacks information on success/failure responses, error handling, or the effect of overwriting existing keys. Given no output schema, this omission is noticeable.

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

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

Schema coverage is 100% with clear descriptions for both key and value. The description adds example keys but does not introduce new semantics beyond the schema. 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 saves data for reuse across sessions/conversations. It identifies the action (save), resource (data), and context, distinguishing it from siblings like recall and forget.

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

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

The description provides concrete when-to-use guidance (e.g., 'when you discover something worth carrying forward') with examples. It mentions pairing with recall and forget, implying alternatives, though it stops short of explicitly stating when not to use this tool.

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

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

Annotations already include readOnlyHint=true, idempotentHint=true, destructiveHint=false. Description adds substantial behavioral context: cross-source identity spine, graceful degradation of LEI/FIGI enrichment, explicit statement of unresolved identifiers, and internal cascading through multiple lookup endpoints. 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 long but densely packed with necessary details. It is front-loaded with examples and a clear directive, then organized by entity type. While somewhat verbose, it avoids fluff and each sentence adds usable information. The length is justified by the tool's complexity.

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

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

Given no output schema, the description fully compensates by explaining what will be returned (identifiers with source labels, unresolved list), how errors are handled (graceful degradation), and the internal cascading behavior. It is complete enough for an agent to select and invoke the tool correctly.

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

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

Schema covers 100% of parameters with descriptions. Description adds extra semantic detail beyond schema: for company, accepts ticker/CIK/ISIN/name; explains ISIN-to-LEI mapping for non-US issuers; for drug returns RxCUI + ingredient + brand. This enriches understanding of how the 'value' parameter behaves.

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 resolves a user-spoken name to canonical/official identifiers, with specific verbs and resources (e.g., 'resolve a user-spoken NAME to the canonical/official identifiers'). It distinguishes from siblings by giving example queries and explicitly saying 'Use FIRST whenever you have a name but need an ID.'

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

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

Provides explicit usage guidance: 'Use FIRST whenever you have a name but need an ID.' It also lists supported entity types and input formats, and notes the tool replaces 2-3 manual lookups, making the intended context clear. Sibling tools like entity_profile are implicitly alternative for post-identification 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, openWorldHint, etc. Description adds behavioral details: probes each entity, ranks by score, returns score/confidence/signal density, which goes beyond annotation scope.

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

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

Three sentences, front-loaded with main action, no filler. Each sentence earns its place with purpose, usage, and output details.

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 4 params and no output schema, description covers input (entities, models, context), process (probes, ranks), and output (ranked list with score/confidence/signal density). Complete for a compare 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?

100% schema coverage, but description adds meaning: first entity treated as subject, models list with default and key requirement, context purpose. This significantly aids agent 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?

Description uses specific verb 'compare' and resource 'AI visibility across multiple entities', and clearly distinguishes from sibling ai_visibility_check by stating it probes each entity and ranks 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?

Explicit use case provided: competitive AI-marketing audits. Implies when to use (multiple entities) vs single entity tool (ai_visibility_check). No explicit when-not-to-use, but context is clear.

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

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

Annotations already provide safety hints (readOnly, idempotent, openWorld). The description adds significant context: fans out across two services, partial failures degrade gracefully, bundlephobia's first measurement can take 5-30s, and sources_failed field reports timeouts. No contradiction.

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

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

The description is relatively long but well-structured: first sentence summarizes the composite action, then details returns, then limitations. Every sentence adds value, though some pruning could improve readability.

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

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

Given no output schema, the description thoroughly explains the return payload (summary block, advisories, links, alternative versions), timeout behavior, and ecosystem scope. It is complete for an agent to use 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% with descriptions for both parameters (package name, optional version). The description adds value by noting scoped packages accepted and version defaults to latest, but the schema already covers the basics.

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

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

The description begins with a clear purpose: a composite check for adding npm packages, covering license, advisories, version history, bundle size, etc. It distinctly separates from siblings as no other tool offers this one-call composite.

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

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

Explicit usage guidance: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. Also notes NPM-only in v1 and directs other ecosystems to deps.dev directly, providing clear when-to-use and when-not-to.

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), the description discloses embedding model (BGE-base-en), windowing (500-char overlapping), similarity metric (cosine), and a 200K char cap with truncation flag, fully informing the agent of behavior.

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

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

Five focused sentences, front-loaded with the core action, each sentence adds unique value (pairing, use case, technical detail) with no wasted words.

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

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

Despite no output schema, the description covers what the tool returns (top-N passages, offsets, similarity scores) and how it handles long inputs, fully preparing the agent for execution.

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

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

Schema has 100% coverage with good descriptions, so baseline is 3. The description adds real-world usage context (e.g., 'the text you already pulled', 'natural-language query') but mostly reinforces schema content, warranting a 4.

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

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

The description clearly states the tool performs 'semantic search INSIDE a fetched record', provides concrete examples (SEC 10-K, article), and distinguishes it from the sibling tool ask_pipeworx_grounded.

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 when to use: 'when the record is too big to cram into the prompt', and offers a pairing with ask_pipeworx_grounded as an alternative workflow, making usage context very 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?

Adds substantial behavioral context beyond annotations: authentication requirements, persistence limitations for anonymous/BYO, rate limits, webhook auto-disable after 10 failures, signing secret returned once. No contradiction with annotations (readOnlyHint=false, destructiveHint=false, etc.).

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

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

Efficient and well-organized with clear sections. Front-loaded purpose; every sentence adds value. Could be slightly more concise (e.g., bullet points), but overall very effective for the 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?

Covers all parameters, types, delivery channels, and constraints. Explains return value (subscription id). Lacks explicit mention of error states or response format beyond id, but given complexity and no output schema, this is adequate.

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

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

Schema coverage is 100%, but description adds rich meaning: type-specific param examples (e.g., items codes for sec_8k), delivery sub-property behaviors (e.g., webhook signing, SMS verification). Adds context not present in schema, such as explanation of item codes and the 'patent_grant' and 'clinical_trial' types.

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

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

Clear verb 'create' and resource 'proactive monitoring subscription'. Distinguishes from siblings like unsubscribe, list_subscriptions, recent_alerts by specifying it initiates a new subscription to a live-data event stream and returns the subscription id.

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

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

Explicitly states requirement for Pipeworx OAuth account, lists supported types with examples, describes delivery channels and constraints (10/day SMS cap, phone verification). Implicitly tells when to use this (to create subscription) and provides context, though does not explicitly 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 indicate read-only, open-world, idempotent, non-destructive behavior. Description adds behavioral context: returns example questions with tool+argument shapes, and that calling with no arguments gives full spread. No contradictions.

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

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

Description is informative but somewhat lengthy with parenthetical lists and examples. While front-loaded with user intents, it could be more concise by trimming redundant examples.

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 return value: category-bucketed example questions with exact tool and argument shapes. It covers usage, parameters, and examples, making it complete for an onboarding tool.

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

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

Schema coverage is 100% with a single optional parameter described. Description adds example values for topic ('finance', 'pharma', etc.) and clarifies that omitting it gives cross-category spread, which adds meaning beyond the schema.

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

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

The description clearly states the tool as the onboarding entry point, returning category-bucketed example questions. It distinguishes itself by listing specific categories and mentioning it's for learning what Pipeworx can do, which is unique among 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?

Explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you', providing clear guidance on when to use. Also mentions optional topic parameter. Does not explicitly state when not to use, but the context is sufficiently clear for an onboarding 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?

Annotations indicate mutation and idempotency. Description adds that the row is deactivated (not deleted) and historical events remain accessible via 'recent_alerts', 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?

Two focused sentences: first states main action and scope, second adds behavioral nuance. No redundant information.

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

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

For a single-parameter tool lacking output schema, the description covers purpose, ownership constraint, and deactivation behavior. Complements sibling tools 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 a single parameter 'id' described as 'Subscription id (uuid) returned by subscribe.' Description adds no extra parameter nuance beyond schema.

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

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

Description specifically states 'Cancel a subscription by id', clearly identifying the verb and resource. It implicitly distinguishes 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?

States ownership enforcement ('you can only cancel your own subscriptions'), providing clear context for when the tool is usable. Does not explicitly exclude scenarios or name alternatives.

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

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

The description adds significant behavioral context beyond the readOnly/openWorld/idempotent annotations. It clarifies the unusual semantics of could_not_verify ('the check did not happen... is NOT evidence') and unsupported ('we looked and cover no source for it'), as well as the structured-vs-grounded routing logic. This aligns with annotations and provides critical caller guidance.

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

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

The description is long but well-organized: trigger phrases, usage, pipeline, return values, and caller warnings are each given focused attention. Every section adds necessary information, and the opening is front-loaded with concrete examples. It could be slightly tightened without loss, but it is not bloated.

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

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

Despite lacking an output schema, the description enumerates all six verdict values, explains the meaning of could_not_verify and unsupported, mentions the pipeworx:// citation, and notes that it replaces 4–6 sequential calls. This is comprehensive for a tool of this complexity and leaves no obvious gaps for an agent to misuse it.

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

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

Schema description coverage is 100% for both parameters, with detailed descriptions of claim and tolerance_pct. The description adds example claims and mentions tolerance implied by wording, but this is already present in the schema. Thus, baseline 3 applies; the description does not add meaningfully 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 natural-language trigger phrases and states it performs 'natural-language claim verification against authoritative sources.' It clearly names the resource (claims) and verb (verify/validate), and distinguishes itself from generic tools like ask_pipeworx by describing its verdict output and dedicated pipeline for fact-checking.

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 whenever the agent needs to check whether something a user said is factually correct.' It also differentiates between company-financial claims (SEC EDGAR fast path) and any other factual claim (grounded pipeline). However, it does not name alternative tools or provide when-not conditions, keeping this at a 4 rather than 5.

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