Funcheap

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds value by explaining the default model (Workers AI Llama-3.3-70b free) and the BYO key requirement for Anthropic calls, which is 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 a single efficient paragraph that front-loads the main purpose. It is clear but could be slightly more structured (e.g., separating output format). No unnecessary words.

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

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

Given no output schema, the description adequately explains the return format (per-model and combined view) and includes use cases. It covers all necessary aspects for agent decision-making, though a more detailed output example would improve completeness.

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

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

Schema coverage is 100% with all parameters described. The description enriches by specifying the exact default model (Llama-3.3-70b) and providing usage hints for the 'context' parameter (e.g., 'Boston restaurant'). This 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 probes LLMs for knowledge about a business/brand/product/topic and returns a visibility score (0-100). It specifies the default model and optional Anthropic probing, making the action and scope unambiguous.

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

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

The description explicitly lists use cases such as AI-marketing audits, pre-launch brand checks, and competitive monitoring, providing clear context for when to use. However, it does not mention when not to use this tool or suggest alternatives among sibling tools.

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

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

The description discloses meaningful behavior beyond the annotations: it routes internally across 5,743 tools, fills arguments, and returns answers with stable pipeworx:// citation URIs. No contradiction with the readOnlyHint/openWorldHint/idempotentHint annotations; only minor caveats like latency or failure modes are omitted.

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 key guidance is front-loaded and useful, but the description becomes highly repetitive: the same example list and 'START HERE for most questions' sentence are repeated multiple times. This is significant redundancy that reduces the clarity of the tool definition.

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 natural-language router tool, the description covers when to use it, how to phrase input, what it does internally, and what kind of output to expect. It is complete enough for an agent to invoke correctly, though explicit differentiation from sibling ask_pipeworx tools would make it more robust.

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

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

Schema coverage is 100%, and the schema already documents that question accepts natural language and that q, text, input, query, and prompt are aliases. The description reinforces this with examples but adds no additional parameter-level semantics beyond the schema.

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

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

The description clearly states that ask_pipeworx routes natural-language factual questions to specialized tools, fills arguments, and returns structured answers with citation URIs. It is well-scoped against web search, but it does not explicitly distinguish itself from sibling variants like ask_pipeworx_grounded or ask_pipeworx_beta.

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 guidance to prefer this tool over web search, says 'START HERE for most questions,' lists trigger phrases, and provides concrete examples. It lacks any when-not-to-use guidance or routing rules among the sibling ask_pipeworx variants and deep_research.

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

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

Annotations already cover read-only, open-world, idempotent, and non-destructive behavior. The description adds meaningful context by disclosing that candidate routing may be live, that none is active as of the given date, and that it is a full working router with no fallback, which is valuable beyond the annotation flags.

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

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

The description is front-loaded with the essential nature of the tool and each sentence adds substance about status, usage, or behavior. It is somewhat dense and repeats the equivalence to ask_pipeworx, but it is still appropriately sized for the information it carries.

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 router with no output schema, the description provides essential context: same response shape, current parity with ask_pipeworx, experimental status, and no fallback. It does not describe the response format, but pointing to the stable sibling's response shape is a reasonable substitute given the close relationship.

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

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

Schema coverage is 100%, so the schema already defines question and the five aliases. The description only adds the cross-reference 'same arguments' without parameter-level detail, which is acceptable but does not raise the score above the baseline.

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

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

The description opens with 'Beta version of ask_pipeworx' and states it is an identical universal router with the same 5,743 tools, arguments, and response shape, which clearly identifies what it does. It distinguishes itself from the stable sibling by the candidate-routing improvements under test, so an agent can separate it from ask_pipeworx without ambiguity.

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

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

It gives explicit guidance: 'Use it exactly like ask_pipeworx when you want the newest routing,' and explains that results are compared against the stable router. It lacks an explicit when-not-to-use statement naming the stable or grounded alternative, so it stops short of a full routing decision rule.

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

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

Discloses substantial behavior beyond the annotations: the extra LLM call cost, the refusal contract with enumerated refusal_reason values, and the exact return shape including evidence as a verbatim quote, confidence, source, and fetched_at. The annotations (readOnly, openWorld, idempotent) cover safety but the description adds the operational behavior an agent needs. No contradiction — the openWorldHint is consistent with routing across 5,743 tools while the extraction remains grounded in the returned data.

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

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

Front-loaded with the key differentiator and densely packed with the return contract, refusal reasons, selection criteria, and cost tradeoff. Slightly longer than necessary, but the length is justified because there is no output schema, so the explicit return/refusal format 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?

Complete for a complex tool: routing behavior, success return shape, refusal semantics with all possible reasons, selection context, and cost implications are all specified. Despite the absence of an output schema, an agent has everything needed to call it correctly and interpret the result, including the refusal contract that explains what happens when the data does not directly answer.

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

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

Schema coverage is 100% and the schema already documents the single required parameter 'question' along with five aliases (query, q, prompt, text, input). The description adds no parameter-level detail, but with full schema coverage the baseline of 3 applies — the schema carries the burden and does so adequately.

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?

States a specific mode ('hallucination-resistant answer mode for high-stakes reads') with a clear verb and resource, and differentiates itself from the sibling ask_pipeworx by describing its distinguishing behavior: it extracts the answer using ONLY what the tool result contains. An agent can tell this apart from ask_pipeworx, ask_pipeworx_beta, and deep_research without inspecting further.

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?

Gives explicit when-to-use guidance with concrete high-stakes scenarios ('financial verdicts, legal claims, medical lookups, public statements') and an explicit when-not-to-use via the cost tradeoff ('prefer ask_pipeworx for casual lookups'). The alternative tool is named directly, leaving nothing to inference.

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

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

Despite comprehensive annotations (readOnlyHint=true, idempotentHint=true), the description adds extensive behavioral details far beyond: market resolution, classification, parallel fan-out, response shapes, resolver contract with match confidence and alternatives, parent event extraction, news fallback mechanisms, safety short-circuits for low-confidence and closed markets, spread warnings, and resolution-rule 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?

Long but well-structured: starts with core purpose, then iterates details (classification, fan-out, response, resolver, etc.). Could trim the classifier list and fan-out examples slightly, but every section adds unique, actionable information. Front-loaded with purpose.

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

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

For a complex tool with no output schema, the description covers all return fields (result.market, result.analysis, result.evidence, resolver contract, parent event, news fields) and edge cases (low confidence, closed markets, wide spreads, resolution-rule risk). Leaves no significant gap for an AI agent to guess.

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% (3 params fully described). Description adds rich meaning: explains the 'market' parameter accepts slug, URL, or question text; 'depth' is tied to fan-out examples; 'include_raw' explicitly describes when to use true vs false. Goes well beyond schema descriptions.

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

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

Description states 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call' with clear verb ('research', 'pull'), resource ('Pipeworx data'), and inputs (slug, URL, question text). It distinguishes its function from siblings like 'polymarket_arbitrage' and 'polymarket_edges' by focusing on research and evidence gathering, but does not explicitly contrast with them.

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

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

Provides explicit usage examples: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z"'. Also includes behavioral guidance on safety (low-confidence matches, closed markets, wide spreads) and resolution-rule risk. Does not explicitly state when not to use it, but context is clear enough.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds 'Sorted by usage', which is behavioral info not in annotations, and provides example category values, enriching transparency 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?

Single sentence with clear purpose, examples, and sorting info. No redundant words or unnecessary details. Front-loaded and efficient.

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

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

Given two optional parameters, no output schema, and rich annotations, the description adequately conveys the return fields (slug, name, count) and sorting. Sufficient for a simple listing 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 both parameters described. The description adds an example query ('neighborhood') but no additional semantic detail 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 lists Funcheap categories with specific fields (slug, name, count), provides examples like 'neighborhoods' and 'fairs-festivals', and mentions sorting by usage. It distinguishes from siblings like 'tags' by focusing on broader groupings.

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

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

The description implies usage for retrieving category lists but does not explicitly state when to use this tool vs alternatives like 'tags' or 'search_events'. No when-not-to-use or exclusion criteria are provided.

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

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

The description discloses key behavioral traits beyond annotations: it pulls data from specific sources (SEC EDGAR/XBRL for companies, FAERS/FDA/clinicaltrials for drugs), handles off-calendar fiscal years correctly, returns sorted results by primary metric, and includes citation URIs. Annotations already indicate read-only, open-world, idempotent, and non-destructive behavior, and the description adds valuable context 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 and well-structured, using parenthetical examples and short clauses. It is front-loaded with natural language queries that the tool handles, and every sentence adds value without redundancy. It efficiently communicates purpose, usage, and returned data.

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

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

Despite having no output schema, the description fully explains what is returned (paired data and citation URIs) and covers both entity types. It addresses edge cases like off-calendar fiscal years and sorting behavior. For a comparison tool with two parameters and clear return expectations, the description is complete and leaves no significant gaps.

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

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

Schema coverage is 100%, but the description adds significant semantic value beyond schema: it explains what data is retrieved for each type (e.g., latest 10-K revenue/net income/cash/debt for companies; adverse events/approvals/trials for drugs), the sorting behavior, and how to interpret the response. This helps the agent understand the parameters' meaning and usage effectively.

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 performs side-by-side comparisons of 2–5 companies or drugs, using clear verb phrases like 'Compare X and Y', 'which is bigger', 'rank these companies'. It distinguishes itself from sibling tools like entity_profile (single entity) and sequential lookups, 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?

The description strongly recommends using this tool over sequential single-pack lookups when comparing entities, and provides context for when to use it. However, it does not explicitly mention when not to use it or suggest alternative sibling tools for different types of comparisons (e.g., comparing other entity types), so guidance is not exhaustive.

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

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

Discloses account and paid-plan requirements, latency ranges, gap[]/contradictions[] behavior, citation_uri resolvability conditions, and semantic excerpting of large records. Annotations already declare read-only/idempotent safety, and the description adds substantial operational context beyond those hints.

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

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

The description is dense and front-loaded with account requirements and sibling routing, and nearly every caveat earns its place. It is slightly long and repeats some depth-level details already present in the schema, so it falls just short of a perfect conciseness score.

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

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

With no output schema present, the description fully compensates by explaining the findings packet, citation field behavior, gaps[], contradictions[], latency, and authentication constraints. An agent has everything needed to decide whether to call this tool, how to set parameters, and what to expect in the response.

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 documents both parameters at 100% coverage, but the description adds practical selection detail, such as the paid-plan requirement for depth:'thorough' and how each depth level affects gap recovery and iteration. This goes beyond the schema's enum descriptions without being redundant.

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?

States a precise action: grounded multi-source research across 1500 structured data sources in one call, with decomposition and parallel routing. Explicitly contrasts with open-web search and names sibling ask_pipeworx, making the tool's function and scope immediately clear.

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

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

Gives explicit when-to-use guidance: best for broad/multi-part structured-data questions; for a single lookup use ask_pipeworx; for world-knowledge/current-events/news prefer ask_pipeworx or ask_pipeworx_beta. It also covers the sign-in exclusion and explains depth-level iteration behavior.

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

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

Annotations already indicate safety (readOnlyHint, idempotentHint, non-destructive). The description adds that it returns top-N relevant tools with schemas and examples, ready to call directly, which is valuable beyond annotations.

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

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

The description is slightly long but front-loaded with purpose and use cases. Every sentence adds value, though minor trimming could improve conciseness.

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

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

Despite no output schema, the description explains the output format (names, descriptions, schemas with examples) clearly. It covers purpose, usage, and results comprehensively given the tool's discovery role.

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 aliases for the query parameter and provides examples, improving usability beyond the schema alone.

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

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

The description clearly states the tool finds tools by describing data or task, lists specific domains, and distinguishes it from siblings by positioning it as the first tool to call when many options exist.

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

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

Explicitly says 'Use when you need to browse, search, look up, or discover what tools exist' and 'Call this FIRST when you have many tools available and want to see the option set', providing clear context and 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?

Beyond readOnly/openWorld/idempotent annotations, the description discloses fan-out across multiple data sources, the semantics of sources_used/sources_failed, that empty sections are real 'no data', and that private companies return resolved:false with a notes line. These are nontrivial behaviors an agent needs to interpret results correctly.

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

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

The description is long but densely informative, with a front-loaded purpose phrase, then a logically ordered fan-out/return/input/edge-case structure. Every sentence adds operational detail; the length is justified by the tool's complexity, and the interchangeability note prevents redundant confusion.

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

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

With no output schema, the description compensates by listing the main returned fields, source identifiers, and failure semantics. It also covers edge cases like private companies and name resolution, so an agent has enough context to invoke the tool and interpret its response.

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

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

The input schema already covers both parameters at 100%, and the description adds concrete examples (AAPL, 0000320193, Moderna), explains that type is interchangeable, and clarifies name resolution through SEC EDGAR. This elevates the baseline 3 to a 4, though no parameter-level syntax is missing.

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

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

The description opens with concrete user phrasings and a clear verb: full cross-source profile of a US public company in one parallel call. It distinguishes itself from single-pack SEC/XBRL/news lookups by name, so an agent can select it without opening schemas.

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

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

It explicitly states ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view. It also specifies accepted value forms and what happens for private companies, giving clear selection and execution criteria.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive behavior. The description adds context about the output: 'full cleaned body text (date/venue/price details live in the text)', which is useful 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 a single concise sentence that front-loads the purpose and identifier methods, with no extraneous information.

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

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

Given no output schema, the description hints at response contents (cleaned body text with date/venue/price). However, it lacks information about error handling or what happens if no event matches. Overall adequate for a simple retrieval 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 descriptive parameter comments. The description does not add significant new meaning beyond what the schema provides, so 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 uses a specific verb ('Get') and resource ('single Funcheap event'), clearly stating the two identification methods: numeric post id or slug. This distinguishes it from sibling tools like 'search_events' which likely returns multiple events.

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

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

The description implies usage when you have an id or slug, but does not explicitly state when to use this tool versus alternatives like 'search_events'. No guidance on choosing between id and slug or when to avoid using 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?

Beyond annotations (destructiveHint=true), the description explains the rationale for deletion and the context, adding value about when deletion is appropriate.

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 the primary action, followed by usage guidance and related tools. No wasted words.

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

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

For a simple single-parameter tool with no output schema, the description provides complete information: purpose, when to use, related tools, and parameter usage.

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

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

Only one parameter 'key' is described; the schema already provides a description ('Memory key to delete'). The description adds no further detail beyond suggesting it matches keys from 'remember' and 'recall', which is minimally helpful.

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

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

The description clearly states the action ('Delete'), the resource ('previously stored memory'), and the method ('by key'). This distinguishes it from sibling tools 'remember' (create) and 'recall' (retrieve).

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

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

Explicitly specifies when to use the tool ('context is stale, the task is done, or you want to clear sensitive data') and provides guidance to pair with related tools 'remember' and 'recall'.

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, and destructiveHint. The description adds behavioral details like fetching the page, extracting data, and emitting markdown. It aligns with annotations and provides context beyond them.

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

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

The description is concise (~60 words), front-loaded with the main action, and well-structured with process, output, and use cases. No unnecessary words.

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

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

Given the simple tool and comprehensive annotations, the description covers main purpose, process, and output format. Missing details on error handling or large page behavior, but adequate for typical use.

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

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

Schema description coverage is 100% with clear parameter descriptions. The description adds context by explaining the extraction process and output format, slightly enhancing 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 generates an llms.txt file for any URL, using specific verbs and resources. It distinguishes itself from siblings by focusing on a specific output format and process.

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 lists three explicit use cases (client indexing, personal project, competitor audit). It does not state when not to use, but the use cases imply appropriate contexts. Could contrast with similar tools like scan_competitor_ai_presence for higher clarity.

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

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

Annotations already provide safety profile (readOnly, nondestructive, idempotent). Description adds useful context about scope (caller's subscriptions) and parameter behavior (active vs inactive). No contradictions.

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

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

Two concise sentences: first states purpose and return fields, second provides usage guidance. No redundant words.

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

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

For a simple tool with one optional parameter and no output schema, the description is complete: purpose, return fields, parameter behavior, and use cases are all covered.

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% for the single parameter 'include_inactive'. The description mentions 'active subscriptions' which relates to the default, but adds no extra 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 lists the caller's active subscriptions and specifies the returned fields (id, type, etc.). It distinguishes from sibling tools like subscribe and unsubscribe by focusing on listing.

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

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

Explicit guidance on when to use: 'review what you're monitoring before adding more' (before subscribe) and 'find an id to cancel' (before unsubscribe). Clear context for appropriate 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?

Beyond the neutral annotations (all false), the description discloses key behaviors: the no-account claim_token flow, passing the token back to check status, rate limiting ('5 per identifier per day'), cost ('free; doesn't count against your tool-call quota'), and the team's daily digest process. This is substantial operational context the annotations do not capture.

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 (~250 words) but justified by the tool's complexity: multiple event types, cross-server disambiguation, claim_token flow, and rate limits. It is front-loaded with a clear purpose statement. Some redundancy like 'signal directly affects roadmap' could be trimmed, but each sentence adds needed operational context.

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

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

For a tool with 4 parameters (1 nested, 0 required), no output schema, and neutral annotations, the description covers all essential context: what it does, when to use/not use, the async token-based follow-up flow, rate limits, cost, and how feedback is consumed. The agent can confidently decide when to invoke this tool and what to pass.

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 already-detailed parameter descriptions. The main description adds extra value by explaining the claim_token workflow in context ('Filing without an account returns a claim_token; pass it back later...'), clarifying message style ('1-2 sentences typical' reinforces the schema), and emphasizing the need to reference Pipeworx tools/packs rather than pasting end-user prompts. This exceeds the baseline for high coverage.

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

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

The description opens with a specific verb+resource: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly differentiates from sibling tools like ask_pipeworx (which are Q&A/research tools) by establishing this as the feedback channel for the Pipeworx tool suite.

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

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

Provides explicit use cases ('Use when a tool returns wrong/stale data... feature/data_gap... praise') and exclusions ('ONLY for tools served by this Pipeworx connection — if the tool came from a different MCP server... file it with that server instead'). Also includes a helpful 'Not sure?' disambiguation for identifying Pipeworx tools.

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

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

Annotations already declare read-only, idempotent, non-destructive. Description adds valuable context: caching (5min-1h), data source (CF analytics-engine, no PII), and self-aggregating nature. 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 concise and front-loaded with purpose, but could be slightly more compact. Every sentence adds value; no filler.

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

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

With no output schema, description adequately specifies return values (top tools, top packs, total call volume) and caching behavior. Sufficient for a simple trending 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 one well-described parameter. Description adds nuance about window choice (hot vs steady-state) beyond the enum 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 uses specific verbs ('returns') and resources ('top tools, top packs, total call volume') and clearly distinguishes from siblings by focusing on what other AI agents are using, not on answering questions or searching.

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?

Three explicit use cases are provided, but no explicit when-not-to-use or alternatives are named. The context is clear enough for an agent to determine applicability.

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 read-only, idempotent, non-destructive behavior. The description adds significant behavioral context: fill check against live CLOB depth, Jaccard similarity threshold (≥0.30), placeholder filter (>20% returns null), and detailed response structure. No contradictions with annotations.

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

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

The description is well-organized but lengthy, covering multiple modes, algorithms, and edge cases. While every sentence adds value, it could be slightly more concise; however, the structure (separating modes, semantic anchor, partition filter, fill check) is clear and logical.

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

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

Despite lacking an output schema, the description thoroughly explains the response structure (opportunities array with fields, partition check details) and all relevant algorithmic behaviors (Jaccard similarity, placeholder filter, fill check). This covers the tool's complexity adequately.

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

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

Schema description coverage is 100%, but the description adds substantial meaning: explains that event accepts slugs or full URLs, topic is a seed question, and provides usage context for each parameter (e.g., recommended mode for specific markets). This goes beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It differentiates three modes (trending scan, event, topic) and explains what each does. While it does not explicitly contrast with sibling tools like polymarket_edges, the purpose is specific and distinct.

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

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

The description provides explicit guidance on when to use each mode: 'Call with NO args for a trending_scan', 'event (recommended for a specific market)', 'topic (for cross-event scanning)'. It also advises against trading when realizable edge ≤ 0 and points to polymarket_fill_risk for custom sizing, offering clear 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=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description goes far beyond by detailing caching (1h at KV level), response segments, diagnostics for empty segments, Fed betting caveats, and the model families. 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 quite long (500+ words) and dense with model-specific details and examples. While it is structured into segments and knobs, it could be more concise. The front-loading is moderate; it starts with purpose but then dives into technical specifics. It earns its place but is not a model of conciseness.

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

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

Given the complexity of the tool (9 parameters, no output schema), the description thoroughly covers the response structure (by_segment, fed_candidates, diagnostics), edge computation details (edge_pp_net, kelly_fraction, liquidity, spread, volume, 24h move warning), and knob effects. It also explains why a segment might be empty and provides diagnostic counters.

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 9 parameters have descriptions). The description adds some contextual guidance for parameters like 'slippage' (zero fees but bid/ask) and 'min_partition_leg_kelly' (why min_kelly doesn't filter partitions), but much of the description focuses on output structure rather than parameter usage. The schema descriptions themselves are already detailed, so the description adds marginal value.

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

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

The description clearly states the tool scans top Polymarket markets and returns opportunities where Pipeworx data disagrees with market price. It uses specific verbs ('scan', 'return') and resources ('Polymarket markets', 'Pipeworx data'), and the context of sibling tools like 'polymarket_arbitrage' and 'polymarket_edge_tracker' helps distinguish it as a discovery tool.

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

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

The description explicitly frames the tool for 'what should I bet on today' and agents discovering opportunities without paging hundreds of markets. However, it does not explicitly state when not to use it or mention alternatives (e.g., use 'polymarket_edge_tracker' for tracking specific edges over time).

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

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

Annotations include readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds extensive behavioral details: it reads snapshots, returns time-series, tracks expired opportunities, explains data gaps due to cache misses, and notes limits like 60-day TTL and snapshot start date. 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 well-structured, front-loading the purpose and then detailing the response structure. It is verbose but every sentence adds value. Could be slightly more concise without losing clarity.

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

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

Given the complexity (multiple arrays, computed fields, time-series) and no output schema, the description thoroughly explains the response: tracked objects with trends, expired opportunities with lifespan, snapshot dates. Also covers limitations (60-day TTL, cache-miss gaps). Highly complete.

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

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

Schema coverage is 100% for both parameters (days, window). The description adds minor context (e.g., 'lookback', 'snapshot family') but largely repeats schema information. No additional semantic depth beyond what the schema provides.

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

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

The description states a specific purpose: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots.' It answers a concrete question ('how long has this edge existed and is it shrinking?') and clearly distinguishes from siblings like polymarket_edges (current edges) and other tools.

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

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

The description provides strong usage context by contrasting a fresh wide edge versus a 3-week-old wide edge, indicating when this tool is critical for trade decisions. It indirectly distinguishes from similar tools (e.g., polymarket_edges) but does not explicitly list when not to use it 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?

Annotations (readOnlyHint, openWorldHint, idempotentHint) are consistent. Description adds behavioral context: it walks the ladder, returns fields like top_of_book, vwap_fill_price, slippage_pp, and warns about thin legs and directional risk. 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 purpose, uses clear sections and bullet-like structure for modes and return fields. Every sentence adds value; no waste. Appropriate length 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?

Handles 4 parameters with 100% schema coverage, no output schema but description enumerates return fields. Good annotations. Completely covers both modes, usage guidance, and edge cases (thin legs, directional risk).

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 substantial meaning: REQUIRES one of market or event, explains single-market vs basket modes, documents defaults for side and size_usd, and describes behavior for each parameter beyond schema comments.

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 checks realizable vs theoretical edge against live CLOB depth, distinguishing single-market and basket modes. It uses specific verbs and resources, and its purpose is distinct from sibling tools 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 when to use: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500'. Provides rationale explaining why, including risks of partial fills and directional exposure.

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

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

Even though annotations already mark the tool read-only, open-world, and idempotent, the description adds substantial behavioral detail: the keyword-overlap pairing method, pairing_unverified semantics, gross-vs-net fee caveats, temporal_alignment null meaning, skipped counters, and the rule that unknown legs are never paired. This goes well beyond the annotations and contains 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 long but well-structured with clear sections for modes, response, safety fields, fees, and skipped counters, and it front-loads the core purpose. Almost every sentence adds a necessary caveat or semantic clarification, though a brief summary line would reduce the cognitive load.

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 thoroughly covers response formats, safety codes, matching behavior, and fee disclosures, which helps compensate for the lack of an output schema. However, with zero required parameters in the schema, it never explicitly states that at least one mode must be supplied, nor does it specify conflict resolution if both topic and explicit identifiers are given.

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 documents all three parameters at 100% coverage, and the description adds useful mode semantics: topic auto-fetches matching events, explicit ticker/slug pairs override the mapped side, and both modes use the same matcher. It does not explain what happens when no parameters are supplied or when both topic and explicit parameters are provided together.

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 by clearly defining the tool as a cross-venue spread between Kalshi and Polymarket for the same resolving question, and it explains the two invocation modes. It does not explicitly contrast itself with sibling tools like polymarket_arbitrage, so differentiation is implied rather than stated.

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

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

The description gives strong when-to-use guidance by distinguishing pre-mapped topic shortcuts from explicit venue pairings, and it warns that pre-mapped topics often return compatibility warnings and are not necessarily tradeable. It does not explicitly name alternative tools or provide a formal when-not-to-use list, but the context is clear.

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

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

Annotations already mark it as readOnly, idempotent, and non-destructive. The description adds valuable context: scoping to an identifier, the ability to list all keys, and the pairing with remember/forget. 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 front-loaded with the tool's action and is concise (three sentences). Every sentence adds essential information: core function, use case, scoping, and pairing with siblings. No unnecessary words.

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

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

Given the simple schema (one optional parameter), no output schema, and annotations that cover safety, the description is fully complete. It explains both modes (retrieve by key or list all), scoping, and relationship to related tools. Nothing is missing.

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

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

Schema coverage is 100% and already describes the parameter well. The description reinforces the meaning ('omit the key argument' to list all keys) and adds context about scoping and the value of retrieval. This adds moderate value beyond the schema.

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

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

The description clearly states the verb ('Retrieve' or 'list') and resource ('value previously saved via remember' / 'all saved keys'), and distinguishes it from sibling tools 'remember' and 'forget' by explicitly mentioning them as pairs.

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 tells when to use the tool ('to look up context the agent stored earlier') and provides an explicit use case. It implies not to use it for re-deriving info, but does not explicitly say when not to use or list alternatives. Still, the guidance is clear and helpful.

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 details beyond annotations: describes returned event structure, mark_read behavior, and feed location. 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?

Concise paragraph with front-loaded purpose, no wasted sentences. Could be more structured but effective.

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

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

No output schema, but description covers return structure and key behaviors. Missing pagination details, but limit parameter addresses it.

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

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

Schema coverage is 100%, and description adds examples and behavioral context for filter parameters beyond schema descriptions.

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

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

Description clearly states the tool pulls fired events from subscription feed, distinguishes from siblings like search_events by focusing on persisted feed.

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?

Mentions polling and alternative HTTP access, but no explicit when-not-to-use. Still provides good 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 already mark it as read-only, idempotent, and non-destructive. The description adds behavioral details: fans out to SEC EDGAR, GDELT→GNews fallback (explains when GNews is used), USPTO (notes soft-fail). Describes return structure: changes[] grouped by source, total_changes, citation URIs. No contradictions.

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

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

Description is comprehensive but not overly long; front-loaded with examples. Could be slightly more concise, but every sentence adds value. Well-organized.

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

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

Given the complexity (multiple data sources, fallback logic, flexible window parameter) and lack of output schema, the description adequately explains what the tool returns (grouped changes, count, URIs). References sibling tool for alternative use case.

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 3 parameters with descriptions. The description significantly enriches: explains since formats (ISO date and relative shorthand with examples), value as ticker or CIK, type as only 'company'. Adds typical usage hints.

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

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

The description starts with specific usage examples (e.g., "What's new with X", "latest on Y") and clearly states the tool's purpose: 'change feed for a company in the last N days/weeks/months'. It distinguishes from the sibling tool entity_profile by explicitly stating when to use that instead.

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

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

Provides explicit when-to-use guidance via example queries and when-not-to-use with 'Use entity_profile instead when you want the static profile...'. Also includes parameter usage tips like using '30d' for typical monitoring.

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 value beyond annotations: explains key-value scoping, persistence differences for authenticated vs. anonymous users, and 24-hour retention. No contradiction with idempotentHint or destructiveHint.

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 concise sentences, front-loaded with purpose. Every sentence contributes essential information—no fluff.

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

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

Covers purpose, usage, parameter semantics, and pairing with siblings. Lacks explicit mention of output/return value, but tool has no output schema, so completeness 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%, so baseline is 3. Description gives example key patterns ('subject_property', 'target_ticker') but does not add new semantic detail beyond schema descriptions.

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

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

Explicitly states the tool saves data for reuse across conversations and sessions, with clear verb ('save') and resource ('data'). Distinct 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?

Provides explicit when-to-use guidance ('when you discover something worth carrying forward') with examples. Implicitly pairs with recall/forget 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?

With readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false already in annotations, the description goes well beyond by disclosing concrete runtime behavior: returns identifiers labelled by source, explicitly lists unresolved identifiers under 'unresolved' instead of omitting them, returns 'figi_candidates' when a name matches multiple instruments, gracefully degrades when GLEIF/OpenFIGI are unavailable, and cascades through multiple endpoints internally. This gives strong transparency into input-to-output behavior with no contradiction against annotations.

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

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

The description is dense and long, but nearly every clause adds necessary behavioral or parameter context. It is front-loaded with user-phrase examples and the 'Use FIRST' directive, then organized by supported type with explicit caveats. Some redundancy exists with the schema's value description (e.g., 'ENTITY NAME ONLY' appears in both), and the parenthetical-heavy style makes it slightly harder to scan, but the structure is logical and no sentence is ornamental.

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

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

There is no output schema, so the description must carry the burden of explaining return behavior, and it does so in detail: CIK/ticker/company_name from EDGAR, LEI and ownership from GLEIF, FIGI from OpenFIGI, RxCUI/ingredient/brand from RxNorm, plus `unresolved` and `figi_candidates` cases. It also covers failure behavior, accepted identifier formats, and the practical benefit of replacing multiple manual lookups. For a tool with this much cross-source complexity, the description is remarkably 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 schema already describes both parameters and reaches 100% description coverage, but the description adds materially beyond the schema: it introduces ISIN as a valid company input, clarifies FIGI lookup behavior for non-ticker instruments, explains the 'ENTITY NAME ONLY' requirement and issuer-exact matching for bonds, and details the `figi_candidates` disambiguation path. These are not just restatements of the schema; they resolve real decision points an agent would face when populating `type` and `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 names a clear verb ('resolve'), a specific resource ('user-spoken NAME to canonical/official identifiers'), and explicitly frames the tool as the input provider for 'other tools require as input.' It also enumerates two distinct entity types, company and drug, and differentiates this resolver from sibling lookup/analysis tools through statements like 'Use FIRST whenever you have a name but need an ID.' This is far beyond a tautology and leaves minimal ambiguity about what the tool does.

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

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

The description gives explicit trigger conditions: 'Use FIRST whenever you have a name but need an ID' and provides detailed scoping for company vs drug lookups, including edge cases like non-equity instruments and ISIN-to-LEI resolution. It does not explicitly name sibling alternatives or state 'do not use when...', but the strong 'use first whenever' guidance plus the input-format details gives an agent clear situational direction.

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

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

Annotations already cover read-only, idempotent, non-destructive. Description adds behavioral details: probes each entity, ranks by score, returns structure (score, confidence, signal density). No contradictions.

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

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

Two sentences, no filler. First sentence states core function, second provides use case and output description. 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?

No output schema, but description specifies return fields (score, confidence, signal density). Covers purpose, input, output, and practical use case. Sufficient for agent selection.

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

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

Schema coverage is 100%, so baseline is 3. Description adds meaning: first entity treated as 'subject', context disambiguates common names, models optional. Enhances understanding beyond schema.

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

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

The description uses specific verbs ('compare', 'probes', 'ranks') and clearly identifies the resource ('AI visibility across multiple entities'). It differentiates from siblings like 'ai_visibility_check' by emphasizing side-by-side comparison.

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

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

Provides clear context for use ('competitive AI-marketing audits') and an example question. Implicitly suggests when not to use (single entity check), but no explicit when-not or named 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 mark it as read-only, idempotent, and non-destructive. The description adds valuable behavioral context: composite nature (fans out across sources), partial failures (graceful degradation), timing (bundlephobia first measurement takes 5-30s), and error reporting (sources_failed list). 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 that efficiently conveys purpose, usage, behavior, and output. It is front-loaded with the main goal. While dense, every sentence earns its place and there is no redundancy. A slightly more structured format (e.g., bullet points) could improve readability, but it is still concise.

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

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

Given the complexity (composite check, multiple sources, partial failures) and lack of output schema, the description completely explains what is returned: a summary block with specific fields, per-advisory details, links, and alternative versions. It also covers ecosystem scope and error handling. No gaps.

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

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

Input schema covers both parameters with 100% description. The description adds clarity: scoped packages like '@types/node' are accepted, and version defaults to latest when omitted. This goes beyond what the schema provides, making it more helpful for an agent.

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

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

The description clearly states it is a composite check for npm packages using deps.dev and bundlephobia, with a specific verb 'scan_dependency' and resource 'npm package'. It distinguishes itself from sibling tools like deep_research or scan_competitor_ai_presence by focusing on package evaluation.

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

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

The description explicitly states when to use: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also notes NPM-only scope and mentions fallback to deps.dev for other ecosystems. While it doesn't explicitly list when not to use, the context is sufficient.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds context about default sorting (newest first) and the scope (SF Bay Area), which enhances transparency. It does not contradict annotations.

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

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

The description is two sentences, front-loaded with the core purpose, and every sentence adds value. No redundant or vague phrases.

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

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

Given the lack of output schema, the description could briefly mention return format (e.g., list of events), but the default sort order and available filters are well-documented. The tool is sufficiently contextual for selection.

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

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

With 100% schema coverage, the baseline is 3. The description adds value by explaining the purpose of facet tags and directing users to the tags tool for slug discovery. It does not repeat schema details unnecessarily.

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

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

The description clearly identifies the tool as searching SF Bay Area free/cheap events from Funcheap, with specific filters like keyword, facet tags, and date range. It distinguishes itself from sibling tools (tags, categories) by referencing them for facet discovery.

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 using the tags/categories tools to discover facet slugs, and states default sort order (newest first). However, it does not mention when not to use this tool vs. alternatives, though the siblings are complementary rather than competing.

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 destructiveHint false, establishing safe read behavior. The description adds crucial details: 'BGE-base-en embeddings + cosine over 500-char overlapping windows; cap is 200K chars (longer inputs are truncated and flagged).' This goes beyond annotations to explain technical limits and how search works, with no contradictions.

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

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

The description is a single, well-structured paragraph. It front-loads the core purpose, then immediately addresses usage, then pairs with alternatives, and finally provides technical details. Every sentence adds value without redundancy. It is appropriately sized for 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 the tool's complexity (semantic search with embeddings, truncation, pairing), the description covers all essential aspects: what it does, when to use, how it works technically, return format (passages with offsets and scores), and interaction with sibling tools. There is no output schema, but the description explicitly states what is returned, making it complete.

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

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

Schema coverage is 100% with descriptions for all three parameters. The description adds operational context by explaining the purpose of passing text and query ('Pass the text you already pulled... plus a natural-language query') and provides example queries. While the schema already describes the parameters, the description enhances understanding of their role in the tool's workflow.

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 'Semantic search INSIDE a fetched record' with a specific verb and resource. It distinguishes itself by explaining the context of searching within a record that is too large for the prompt, and mentions a complementary sibling tool (ask_pipeworx_grounded), differentiating its role.

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

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

Explicitly states when to use: 'Use when the record is too big to cram into the prompt.' It explains the benefit (saves context, returns only passages that matter) and provides an alternative: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document.' This guides the agent on both usage and exclusivity.

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

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

Beyond annotations (readOnlyHint=false, idempotentHint=true, etc.), description adds rich behavioral details: delivery channel behavior (feed always on, email/sms/webhook), phone verification, SMS cap, webhook auto-disable, and signing secret. No contradiction with annotations.

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

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

Single paragraph with dense but organized information. Front-loaded with purpose and requirement. Could be more scannable with bullets or sections, but all content 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 no output schema, description explains return value ('Returns the new subscription id'). Covers purpose, requirements, types, delivery options, and constraints. Missing error scenarios but sufficient for a subscription creation tool.

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

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

Schema coverage is 100%, but description adds substantial meaning: type examples for each enum, detailed param structures for each subscription type, and explanation of delivery sub-properties (including webhook signing).

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 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' Specific verb (create) and resource (subscription). Distinguishes from sibling tools like 'list_subscriptions' 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?

Provides explicit requirement: 'Requires a Pipeworx OAuth account (anonymous + BYO cannot persist subscriptions).' Also lists supported types and delivery channels. Does not explicitly state when not to use, but context is clear.

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

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

The description fully discloses behavior: it returns category-bucketed example questions with exact tool calls, can be called with no arguments or a specific topic, and draws from a live catalog. Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) are not contradicted and the description adds meaningful context beyond them.

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

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

The description is a single, well-structured paragraph. It front-loads key purpose and example questions, each sentence earns its place, and there is no fluff. The information density is high but still readable.

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

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

Given the tool has one optional parameter and no output schema, the description covers everything an agent needs: purpose, usage timing, argument behavior, and what to expect as output. It is fully complete for its complexity.

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

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

Schema coverage is 100% with a clear description of the topic parameter. The description reinforces this by listing allowed values and explaining the effect of omission vs. providing a topic, adding usage nuance beyond the schema.

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

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

The description clearly identifies the tool as the onboarding entry point for agents, listing example queries and specifying it returns category-bucketed example questions with tool+argument shape. It distinguishes itself from siblings like ask_pipeworx by stating it should be used first when the agent doesn't know what Pipeworx can do.

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

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

The description explicitly tells when to use this tool: 'Use this FIRST when you do not yet know what Pipeworx can do for you, or to learn how to call the meta-tools.' It also explains how to use the optional topic parameter to focus a category, and that omitting it gives a full spread.

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, openWorld, idempotent, and non-destructive. The description adds value by specifying the returned fields (slug, name, count) and that results are sorted by usage, which are not covered by annotations.

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

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

The description is a single sentence that immediately states the purpose, followed by clarifying examples and sorting detail. Every word earns its place with no redundancy.

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

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

Given the simplicity of the tool (2 optional parameters, no output schema), the description adequately explains that it returns tag slug, name, and count sorted by usage. It could mention that per_page defaults to 40 but that is in the 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% with descriptions for both parameters. The tool description does not add additional meaning beyond what the schema already provides for 'query' and 'per_page', 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 the tool lists Funcheap event facet tags (slug, name, count) and gives concrete examples like 'free', 'live-music', 'comedy'. It distinguishes from sibling tools like 'categories' by specifying these are filterable facets.

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

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

The description implies usage for retrieving available event tags but does not explicitly state when to use this tool versus alternatives like 'categories' or 'search_events'. No exclusions or when-not-to-use guidance provided.

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

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

Discloses that 'The row is deactivated (not deleted) so its historical events stay available via recent_alerts,' adding important behavioral detail beyond annotations. 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 providing necessary information without redundancy. Every sentence adds value.

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

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

With one parameter, no output schema, and annotations present, the description fully covers the tool's behavior, ownership, and side effects.

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 parameter description. The tool description does not add significant meaning beyond the schema, so 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?

Clearly states 'Cancel a subscription by id.' The verb 'cancel' and resource 'subscription' are specific, and it distinguishes from siblings like 'subscribe' and 'list_subscriptions'.

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

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

Explicitly mentions ownership enforcement: 'you can only cancel your own subscriptions.' This provides clear context for appropriate use, though it doesn't explicitly state when not to use 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?

Beyond the annotations (readOnly, idempotent), the description richly discloses behavior: it details return verdicts (confirmed, refuted, etc.), the meaning of could_not_verify and unsupported, that could_not_verify must not be treated as evidence for/against, and that evidence includes verbatim citations and reasoning. This is substantial added transparency for a complex verification tool.

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

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

The description is quite long but densely packed with necessary information. It is front-loaded with example queries and organized logically: purpose, usage, pipeline routing, return format, edge cases, and efficiency note. Every sentence earns its place, though it could be slightly tightened.

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

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

With no output schema, the description fully explains the return value (verdict, actual value with citation, reasoning) and covers edge cases like could_not_verify and unsupported in detail. It also addresses both financial and non-financial claim paths, making it complete for a tool of this complexity.

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

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

Schema description coverage is 100% for the two parameters, so the baseline is 3. The description adds meaning by explaining how tolerance_pct interacts with claim wording and suggests setting 1–2 for hallucination detection, which is valuable beyond the schema. This 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 defines the tool as natural-language claim verification against authoritative sources, with verb 'validate' and resource 'claim'. It gives explicit example queries and distinguishes itself from generic Q&A by detailing specialized financial vs. other factual claim pipelines, and by noting it replaces 4–6 sequential calls.

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

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

The description explicitly states when to use it: 'Use whenever the agent needs to check whether something a user said is factually correct.' It also explains how different claim types are routed (financial vs. other), which is strong usage context. However, it does not explicitly mention exclusions or alternatives, so it falls short of a 5.

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