Exoplanet Archive

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

Annotations already indicate safe, read-only behavior. The description adds value by disclosing external API calls, per-model returns, cost implications for Anthropic, and the response structure. No contradictions.

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

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

The description is concise (3-4 sentences), well-structured, and front-loaded. Every sentence provides useful information without redundancy.

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

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

Given no output schema, the description adequately describes return fields (score, confidence, signals, raw_response) and combined view. It covers all key aspects for an agent to understand and invoke the tool correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description explains default model and API key usage but does not add substantial meaning beyond the schema's parameter descriptions.

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

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

The description specifies a clear action ('probe one or more LLMs') and resource ('business/brand/product/topic'), with specific output (visibility score 0-100). It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on any entity, not just competitors.

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 states use cases ('AI-marketing audits, pre-launch brand checks, competitive monitoring') and clarifies default model and API key requirements. However, it does not explicitly mention when not to use or name alternative tools.

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

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

Description adds critical behavioral context beyond annotations: routes to one of 5,564 tools, fills arguments, returns structured answers with stable citation URIs. It also notes it is fast and works on every tier. No contradiction with annotations (readOnlyHint, openWorldHint).

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

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

Well-structured with a clear hierarchy: primary recommendation, use cases, examples, alternatives. Though somewhat long, every sentence earns its place by providing actionable guidance. Slightly front-loaded, making the key message immediate.

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 (many underlying sources, no output schema), the description provides everything needed: purpose, scope, output format (structured with citations), alternatives, and examples. Compensates for missing output schema by describing the result nature. Fulfills the requirements for a high-complexity tool.

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

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

Schema coverage is 100% with property descriptions and aliases. The description adds value through examples that demonstrate the natural language input format and the range of questions accepted. This helps the agent formulate better queries beyond the schema's dry property definitions.

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

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

The description clearly states the tool routes factual questions to authoritative sources and returns structured answers with citations. It specifies the domains (SEC filings, FDA, weather, etc.) and distinguishes from siblings like ask_pipeworx_grounded and deep_research. The purpose is precise and action-oriented.

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 'PREFER OVER WEB SEARCH' and lists when to use (factual questions, 'what is', 'look up', etc.) and when to step up to alternatives (ask_pipeworx_grounded for verbatim evidence, deep_research for multi-part). Provides concrete examples, making it easy for the agent to decide.

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

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

Annotations already indicate readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds crucial behavioral context: that it is a live beta with possible routing improvements, currently identical to the stable version, and that results are compared to decide what merges. This exceeds expectations by explaining the experimental nature without contradicting annotations.

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

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

The description is a single, well-structured paragraph that front-loads the key points: it's a beta version, identical to the stable one, with candidate improvements. Every sentence provides critical information about current state, usage, and purpose, with no wasted words.

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

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

Given the tool's complexity (5,564 tools, no output schema), the description is quite complete: it explains the relationship to the stable router, current inactivity of candidates, and fallback behavior. It misses nothing essential for an agent to use it correctly, though a brief note on expected response shape could be beneficial but not necessary given the sibling context.

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

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

Schema description coverage is 100%, so the schema thoroughly documents all six parameters as aliases for question. The description does not add further parameter semantics beyond what the schema provides, so a baseline of 3 is appropriate. No additional meaning is added.

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

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

The description clearly states the tool is a beta version of ask_pipeworx, an identical universal router with the same tools, arguments, and response shape. It distinguishes itself by noting candidate routing improvements are occasionally tested but currently none are active, so it matches ask_pipeworx exactly. This is specific and differentiates from siblings like ask_pipeworx and ask_pipeworx_grounded.

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

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

The description explicitly states to 'Use it exactly like ask_pipeworx when you want the newest routing' and explains the fallback behavior clarifies it's a full working router, not a backup. It doesn't mention when not to use it, but the context of beta testing and comparison to a stable router provides clear guidance for selection.

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

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

The description extensively details behavioral traits beyond annotations: the tool routes picks the right tool from thousands, fills arguments, fetches data, then extracts only from tool results. It lists exact return fields including evidence (verbatim quote) and possible refusal reasons. Annotations already mark readOnlyHint, openWorldHint, idempotentHint, and destructiveHint as false, and the description aligns with these 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 at 3 sentences, front-loading the key purpose 'hallucination-resistant answer mode' and then providing usage guidance. Every sentence adds value, though it could be slightly more compact by merging the refusal reason list into a more condensed form. Still, very efficient for the information conveyed.

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 (high-stakes reads, routing across 5,564 tools, 1462 sources), the description fully explains behavior, return structure, refusal reasons, and when to use alternatives. No output schema exists, but the description enumerates all return fields including refusal reasons, compensating adequately. Sibling tools like ask_pipeworx are referenced, providing complete context.

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

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

Schema description coverage is 100% and all parameters are aliases for question with clear descriptions. The description adds context on how the question is used (natural language, accepts aliases) but the schema already documents each alias. A score of 4 is warranted because the description adds value by explaining the query routing context, though the schema already handles parameter documentation well.

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 provides a 'hallucination-resistant answer mode for high-stakes reads,' specifies it extracts answers using only tool results, and returns an explicit structured response with refusal reasons. This distinguishes it well from its sibling ask_pipeworx 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 explicitly tells when to use: 'whenever an answer will be quoted, cited, or acted on' and provides concrete examples (financial verdicts, legal claims, medical lookups, public statements). It also explicitly tells when not to: 'prefer ask_pipeworx for casual lookups,' and costs one extra LLM call.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description goes far beyond, detailing fan-out logic, resolver contract, parent event extraction, news fallback, short-circuit conditions for low-confidence matches, closed markets, wide spreads, and resolution-rule risk—all critical for safe invocation.

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 very long, covering classifiers, fan-out examples, response shapes, resolver contract, and numerous edge cases. While comprehensive, it lacks conciseness; an agent must parse many paragraphs to extract the core purpose. Front-loading is good but overall verbosity lowers the 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?

Despite lacking an output schema, the description thoroughly explains return fields (result.market, analysis, evidence, resolver contract, parent event, news fallback). Every major behavior and edge case is covered, making the tool's response predictable and safe to use.

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

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

Schema coverage is 100% with descriptions, but the tool description adds significant value: clarifies the 'market' parameter accepts slug, URL, or question text; explains 'depth' quick vs thorough; details 'include_raw' payload size implications. This goes well beyond schema definitions.

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

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

The description clearly states the tool researches Polymarket bets by pulling Pipeworx data in one call. It specifies input types (slug, URL, question text) and provides examples, distinguishing it from sibling tools focused on general queries or other domains.

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

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

The description includes explicit use cases ('should I bet on X', 'what does the data say about Y', 'is there edge in Z') and concrete examples. While it does not directly compare to siblings, the context is clear enough for an agent to know when to invoke it.

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

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

Discloses data sources (SEC EDGAR, FAERS), fiscal year handling, sorting behavior, and citation URIs, adding value beyond annotations.

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

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

Front-loaded with example queries, uses dashes for readability, and every sentence is informative.

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

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

Covers return format, data details for both types, and efficiency gains, making it complete despite no output schema.

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

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

Adds meaning beyond schema by explaining enum values, data content, and exact input formats for each type.

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

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

Describes the tool as a side-by-side comparison of 2-5 companies or drugs, with specific usage examples and differentiation from sequential lookups.

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

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

Provides clear guidance to prefer over sequential lookups and gives query examples, but does not explicitly state when not to use.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, indicating a safe read operation. The description adds no behavioral context beyond stating the table name, missing opportunities to mention rate limits, pagination, or return format.

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 under-specified, not concise. A single sentence naming a table does not efficiently convey tool functionality; every word should add value, and this does not.

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 2 parameters with no schema descriptions and an output schema exists, the description is completely inadequate. It fails to specify how the tool behaves, what it returns, or any constraints, making it nearly useless for an AI agent.

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

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

The input schema has 0% description coverage, and the description does not explain the meaning of 'limit' or 'query'. There is no hint about query syntax or default behavior, leaving the agent without essential parameter semantics.

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

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

The description 'Composite planet parameter table `pscomppars`' names a table but lacks a verb or action. It does not clarify whether the tool queries, lists, or retrieves data, leaving the purpose vague. It is nearly a tautology of the name.

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

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

No guidance is provided on when to use this tool versus alternatives. Without context, the agent has no indication of appropriate scenarios or exclusions.

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

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

With annotations already declaring readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, the bar is lower, but the description adds substantial behavioral context: account/auth requirements, that large records are semantically excerpted (not head-truncated), that gaps[] are returned for unanswered facets (never invented), that citations are stable pipeworx:// URIs present only when fetchable, expected response time (15-60s, up to ~90s for thorough), and the hop field in findings. All annotations are consistent with the description (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 every sentence adds valuable information—account requirement, when/not to use, citation behavior, iteration behavior, excerpting strategy, contradictions, timing. It's front-loaded with the most critical constraint (account needed) and the sibling alternative. One slight markdown for length (could be slightly tighter in the middle) but no wasted sentences.

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

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

Given the tool has 2 params, 100% schema coverage, no output schema, and moderate complexity (iterative research with multiple depth levels), the description is remarkably complete. It covers auth prerequisites, when/not to use, alternatives, expected timing, citation format, gap handling, excerpting behavior, and hop iteration. The only minor gap is that it doesn't explicitly say what the return format looks like structurally, but the description compensates with a clear enumeration of the findings packet contents.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value beyond the schema by explaining the behavioral implications of each depth value (number of facets, gap-recovery hop, contradictions scan) and clarifying that the question should be broad/multi-part (decomposition is the point). This justifies a 4—the description enriches understanding of both params beyond the raw schema. Not a 5 because the schema already provided reasonable descriptions.

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

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

The description clearly states it performs grounded multi-source research across structured data sources in one call, and distinguishes itself from siblings like ask_pipeworx and ai_visibility_check by specifying it's not open-web search and decomposition is the point. The verb 'research' combined with 'grounded multi-source research across structured data sources' and the explicit contrast with ask_pipeworx's single-lookup behavior make the purpose specific and 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?

Excellent usage guidance: explicitly says when to use (broad/multi-part questions over structured data), when NOT to use (breaking news, colloquial current-events, single lookups), and provides named alternatives (ask_pipeworx for single lookups and for breaking/current-news topics, with the reason that deep_research would return empty gaps). Also covers prerequisites (account required, paid plan for 'thorough') and fallback (use ask_pipeworx if not signed in). Also explains second-hop iteration behavior and when contradictions appear.

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 and idempotentHint=true. The description adds value by explaining that the tool returns top-N results with full schemas and curated examples, ready to call directly, and mentions it is a discovery tool. 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 with a clear purpose first, followed by usage guidance and output details. It is slightly verbose but every sentence adds value. Could be trimmed slightly for conciseness, but overall efficient.

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

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

Given the tool's discovery role, the description fully covers what it does, when to use it, and what it returns. No output schema is needed as the tool returns schemas directly. The description is complete and leaves no ambiguity.

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

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

Schema coverage is 100% with detailed parameter descriptions including aliases. The description reinforces the query flexibility but does not add significant new semantic information beyond the schema. Given high schema coverage, baseline is 3, but the description's contextual summary earns a 4.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists specific domains (SEC filings, financials, etc.) and contrasts with sibling tools by advising to call it FIRST when many tools are available.

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

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

Explicit guidance on when to use: 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It also implies not to use when you already know the tool, providing clear usage context.

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

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

Annotations already set readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds significant behavioral context: it fans out across multiple data sources, returns specific fields with caveats (e.g., patents 'soft-fails until reactivated'), and provides URIs for filings. 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 relatively long but front-loaded with example queries. Each sentence adds value (usage guidance, behavioral details, parameter constraints). While slightly verbose, it remains well-structured with a clear logical flow.

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

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

No output schema exists, so the description bears full burden of explaining outputs. It thoroughly lists all returned fields: cik, company_name, recent_filings (up to 5 with URIs), fundamentals (latest 10-K data), patents (with caveat), recent news, LEI. This covers the tool's complexity comprehensively.

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

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

Schema coverage is 100%, and the description adds meaningful context beyond the schema. For 'type', it notes only 'company' is supported with future plans for 'person/place'. For 'value', it explains acceptable formats (ticker or zero-padded CIK) and explicitly states names are not supported, directing to a sibling tool.

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: 'full cross-source profile of a US public company in ONE parallel call.' It lists multiple data sources and specific outputs, and explicitly distinguishes itself from chaining individual lookups and from sibling tools like 'resolve_entity' by noting that names are not supported and should be resolved first.

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

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

The description provides explicit when-to-use guidance ('ALWAYS PREFER over chaining single-pack... lookups when the user asks for a holistic view') and when-not-to-use ('names not supported — use resolve_entity first if you only have a name'). It also suggests an alternative tool for name resolution.

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 set destructiveHint=true, idempotentHint=true, and readOnlyHint=false. The description adds context about why deletion might be needed (stale data, sensitive data) but doesn't disclose additional behavioral traits 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?

Three sentences, each serving a distinct purpose: stating action, providing usage scenarios, and suggesting related tools. No redundancy or wasted words.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, usage guidance, and relationships thoroughly. No gaps remain.

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

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

Schema coverage is 100% with a clear description for the parameter 'key' ('Memory key to delete'). The tool description does not add further semantic information 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 clearly states the action 'Delete a previously stored memory by key', specifying the verb, resource, and mechanism. It distinguishes from sibling tools like remember and recall by focusing on deletion.

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

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

Explicitly lists when to use: when context is stale, task is done, or to clear sensitive data. Also mentions related tools (remember, recall), providing clear guidance on tool selection.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds details about fetching, extracting title/description/key links, and output format. 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 plus a list of use cases. Front-loaded with main purpose. 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?

For a simple tool with 2 params, full schema coverage, and rich annotations, the description covers purpose, behavior, output, and use cases completely. No gaps.

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

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

Schema coverage is 100% with descriptions for both parameters (url, max_links). The description mentions extraction of 'title/description/key links' which relates to parameters but does not significantly add 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's purpose: 'Generate a production-ready llms.txt file for any URL'. It includes specific verb (generate) and resource (llms.txt file), and mentions context for AI crawlers. It distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on file generation.

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: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor.' While it doesn't state when not to use or name alternatives, the use cases guide the agent effectively.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint true, and destructiveHint false, which the description merely echoes by implying a read-only table. No additional behavioral context (e.g., pagination, filtering capabilities, result set size) is provided 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 extremely concise (one sentence) but lacks essential details. It is front-loaded but under-specified, sacrificing completeness for brevity.

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

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

Despite the presence of an output schema (reducing the need to explain return values), the description is incomplete: it does not explain the purpose of the two parameters, nor does it provide usage guidance or behavioral context. For a tool with 2 optional parameters, this is insufficient.

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

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

Schema description coverage is 0%, and the description does not mention the 'limit' or 'query' parameters. The schema examples provide some hints, but the description adds no meaning to interpret these parameters.

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 'Kepler Object of Interest (KOI) candidate table' is a noun phrase that identifies the resource but does not state what action the tool performs (e.g., query, list, search). It is distinguishable from siblings like 'planets' but lacks a specific verb. This is adequate but not explicit.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'planets' or 'microlensing'. The description offers no context for appropriate use cases or exclusion criteria.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, fully covering the safety profile. The description adds that it returns specific fields and usage purpose, but this is minimal additional behavioral context 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 two sentences long with zero fluff. The first sentence immediately states the core action, and the second adds usage context. Every sentence earns its place.

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

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

Given the tool has rich annotations covering safety and idempotency, a single optional parameter documented in the schema, and no output schema needed, the description is complete. It specifies return fields and usage context, making it sufficient for an agent to use correctly.

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

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

Schema coverage is 100% with one boolean parameter fully described. The description does not mention the parameter or add any semantic nuance beyond the schema, so the baseline score of 3 applies.

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. It implies relationship to subscribe/unsubscribe through usage hints but does not explicitly differentiate from siblings.

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

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

The description provides explicit guidance: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' This gives clear context for when to use the tool, though it does not include explicit 'when not to use' statements.

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

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

The description adds no behavioral context beyond what annotations already provide. Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, so the agent already knows this is a safe read operation. 'Microlensing event table' does not describe any traits like filtering behavior, pagination, or output format.

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

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

The description is extremely concise and front-loaded: a single phrase with zero wasted words. However, its brevity comes at the cost of substance, so while it's well-structured for length, it's under-specified for utility.

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

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

Despite having an output schema and annotations, the description is incomplete. It offers no explanation of what a microlensing event table contains, how to formulate queries, or how results are limited/ordered. For a tool with a query parameter, it leaves too much implicit.

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

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

Schema description coverage is 0%, so the description must compensate. It does not mention 'limit' or 'query', leaving their meaning entirely to the schema (which also lacks descriptions). The examples in the schema hint at query syntax, but the description itself provides no parameter semantics.

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

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

The description 'Microlensing event table' is a noun phrase with no verb, so it doesn't explicitly state what the tool does (e.g., 'List microlensing events'). It conveys the resource but not the action, and it fails to distinguish from sibling tools like 'planets' or 'kepler_candidates', which are also astronomical data tables.

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?

There is no guidance on when to use this tool versus alternatives. The description provides no context about querying microlensing events or when this dataset would be preferred over sibling tools like 'planets' or 'kepler_candidates'.

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

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

Annotations are sparse (no readOnly, destructive, idempotent hints), but the description identifies the result format (claim_token), explains how to use the returned token later, notes daily rate limits, and clarifies that it doesn't count against quota. This adds meaningful behavioral context beyond annotations, though it doesn't detail the exact response envelope beyond claim_token.

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

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

The description is dense but well-structured: starts with a clear summary, then elaborates on use cases, exclusions, and mechanics. It is longer than average, but every sentence adds critical usage information. The only minor deduction is that the 'rate-limited' and 'free' details could be considered extras, though they are still useful.

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 (4 params, nested objects, conditional token usage, clear exclusion rules), the description covers all necessary aspects: what to report, what not to report, how to claim a feedback response, and the expected message format. Absence of an output schema is compensated by explicitly mentioning the claim_token return value. The description is complete for an agent to invoke safely and correctly.

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

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

The input schema is fully described (100% coverage) and the description reinforces parameter semantics for type, context, message, and claim_token, especially the special usage of claim_token with no other arguments. It also gives examples and constraints (1-2 sentences, 2000 chars max) that enrich the schema. Since schema coverage is high, a baseline 3 is appropriate, but the description adds enough extra behavioral detail to warrant a 4.

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

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

The description clearly states the tool's purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It specifies a verb (tell) and resource (Pipeworx team) and distinguishes itself from siblings by focusing on feedback about Pipeworx tools themselves, not asking questions or researching entities like ask_pipeworx or deep_research.

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

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

The description provides explicit when-to-use guidance: use for bugs, feature requests, data gaps, or praise. It also provides an explicit exclusion: do NOT report tools from other MCP servers, and tells users how to identify which tools belong to this connection. This is exemplary usage guidance.

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

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

Annotations already declare read-only, idempotent, open-world. Description adds that data is self-aggregating, derived from analytics engine, no PII, and cached 5min-1h. No contradictions.

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

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

Six sentences, front-loaded purpose, then use cases, then details. 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?

Though no output schema, description specifies what is returned (top tools, top packs, total call volume) and that results are cached. Sufficient for agent comprehension.

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

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

Schema coverage 100% with enum and description. Description explains effect of different windows, adding value beyond schema.

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

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

The description clearly states it returns top tools, top packs, and total call volume over a window. It distinguishes from siblings by focusing on real-time trending aggregated from other agents' 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?

Explicitly lists three use cases (discovering hot data sources, confirming popular tool, aligning use case). Does not state when not to use, but use cases are 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, openWorldHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds minimal context (the table name and 'quick'), but does not disclose additional behavioral traits such as return limits, pagination, or special query syntax beyond what the schema provides. 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, front-loaded sentence that conveys the core purpose without wasted words. It is appropriately concise for a simple search tool.

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

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

Given the tool's simplicity, the presence of a complete schema, output schema, and strong annotations, the description is mostly sufficient. However, it lacks usage context relative to sibling tools (e.g., when to prefer `planets` over `kepler_candidates`), which slightly reduces 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 description coverage is 100%, with clear descriptions for both `limit` and `query`. The description itself adds no parameter-specific meaning, but the schema fully documents the parameters, so the baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as a search against the `ps` (planetary systems) table with the verb 'search,' which is specific. However, it does not explicitly differentiate from sibling tools like `kepler_candidates` or `microlensing`, so it lacks explicit sibling distinction.

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

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

No guidance is provided on when to use this tool versus alternatives. The description simply states it is a 'quick' search, with no mention of use cases, prerequisites, or exclusions. This leaves the agent without context for tool selection.

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

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

The annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds significant behavioral context: it explains the use of external APIs, the Jaccard similarity filter, placeholder filtering, and the fill check against live CLOB depth. 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 thorough and well-structured, with clear sections for each mode and checks. It is slightly verbose but every paragraph adds essential information. It is front-loaded with the core purpose.

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

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

Despite lacking an output schema, the description fully explains the response structure (opportunities array, partition_check, fill check results) and covers edge cases like null signals, placeholder filtering, and low similarity. It is comprehensive.

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

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

The input schema has 100% description coverage for its two parameters. The description goes beyond the schema by explaining that event is a slug or URL, topic is a seed question, and detailing the behavior of each mode. This adds valuable context.

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

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

The description clearly states that the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes between three modes (no args, event, topic) and explains the output structure. It is distinct from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

The description provides explicit guidance on when to use each mode: no args for trending scan, event for a specific market (recommended), and topic for cross-event scanning. It also advises against trading when realizable_edge_pp <= 0 and suggests using polymarket_fill_risk for custom sizing.

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

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

The description provides extensive behavioral information: caching strategy (1h KV), response structure (by_segment with detailed segments), edge calculation methodology, slippage handling, Kelly sizing, and diagnostics for empty segments. This goes well beyond the readOnlyHint and idempotentHint annotations.

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

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

The description is well-structured with section headers (FIVE MODEL FAMILIES, TRADEABLE-EDGE KNOBS, RESPONSE TOP-LEVEL) and front-loads the purpose. While long, the length is justified by the tool's complexity and lack of output schema. 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?

Despite 9 parameters and no output schema, the description covers all necessary aspects: model families, edge calculation, output segments, diagnostics, caching, and edge cases (e.g., empty segments, Fed markets). It is self-contained enough for an AI agent to use correctly.

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

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

Schema documentation covers 100% of parameters. The description adds context like explaining slippage in practical terms (Polymarket fees, bid/ask depth) and the distinction between min_kelly and min_partition_leg_kelly. This adds value beyond the schema.

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

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

The description clearly states the tool scans Polymarket markets for opportunities where Pipeworx data disagrees with market price, with a specific use case 'what should I bet on today'. It distinguishes itself from siblings like polymarket_arbitrage and polymarket_edge_tracker by focusing on Pipeworx disagreement and being 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 targets a use case ('what should I bet on today') and explains that it avoids paging hundreds of markets. It details tradeable-edge knobs and filtering, but does not explicitly state when not to use it or directly compare to all siblings.

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

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

The description extensively discloses behavior beyond annotations: details of returned arrays (tracked, expired, snapshot_dates), sign interpretation of edge_pp_net, and computation method. Annotations (readOnlyHint, idempotentHint) are consistent, 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 well-structured with clear sections for purpose, arguments, response format, and limitations. It is somewhat verbose but each sentence adds value. Front-loaded with the core question it answers.

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

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

Given the tool's complexity and lack of output schema, the description covers inputs, outputs, and limitations thoroughly. It explains return fields and edge interpretation. However, it could mention that the tool is safe/idempotent (already covered by annotations).

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

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

Schema description coverage is 100%, so the description adds minimal value beyond restating defaults and ranges. It provides a slight clarification (clamp vs max) but does not introduce new semantic context.

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

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

The description clearly defines the tool as providing edge persistence and decay telemetry, answering a specific question about edge age and shrinkage. It distinguishes from sibling tools like polymarket_edges by focusing on time-series insight rather than current snapshots.

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 states the tool's use case ('how long has this edge existed and is it shrinking?') and provides context about when it is relevant (e.g., distinguishing a fresh edge from an old one). It also mentions limitations (TTL, snapshot gaps). However, it does not explicitly list when NOT to use it or compare with alternative tools.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, consistent with a read-only check. The description adds behavioral details: it walks the order book ladder, returns fill metrics (top_of_book, vwap_fill_price, slippage_pp, etc.) and a verdict (clean|degraded|cannot_fill). It also warns about thin legs and forced directional risk, going 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 well-structured with clear sections (REQUIRES, SINGLE-MARKET, BASKET, USE THIS). It is slightly verbose but every sentence adds necessary context. The front-loading of purpose and usage guidance is effective.

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

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

Given the tool's complexity (two modes, no output schema, 4 params), the description comprehensively covers return fields, edge cases (thin legs, partial fills), and practical risks. It compensates for the missing output schema by detailing expected return values and verdicts.

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 4 parameters. The description adds richer semantics: explains the dual-mode interpretation of 'side' (default auto for basket), clarifies 'size_usd' as max spend vs target proceeds for singles, and settlement notional for baskets. This helps the agent understand parameter behavior beyond the schema.

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

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

The description clearly states the tool performs a 'realizable-vs-theoretical edge check against live CLOB order-book depth.' It distinguishes between single-market and basket modes, and explicitly tells when to use it (before executing arbitrage or edge trades), differentiating it 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?

The description provides explicit usage guidance: 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500.' It explains the risks of partial basket fills converting arbitrage into unhedged directional positions, and gives conditions for each mode.

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, destructiveHint. The description adds critical behavioral context: compatibility_warning conditions, temporal_alignment field, skipped_cross_type/subtype counters, and the fact that spreads are only meaningful when aligned. 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 but well-structured: purpose first, then modes, response fields, and safety details. Every sentence adds value, though some redundancy exists (e.g., repeated explanation of compatibility warnings). Front-loading is good.

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

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

Despite no output schema, the description thoroughly explains the response structure (leg-by-leg prices, spread array, top_spreads_pp, safety fields like compatibility_warning and temporal_alignment). It also covers edge cases like mismatched bet shapes and temporal gaps, making it complete for tool invocation.

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

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

Schema coverage is 100%, and the description adds substantial meaning: the topic parameter is fully enumerated with all 10 shortcuts, the override behavior for explicit tickers is explained, and examples are provided. This goes beyond the schema's property descriptions.

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

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

The description explicitly states the tool computes cross-venue spreads between Kalshi and Polymarket for the same resolving question, with specific verb ('cross-venue spread') and resource. It distinguishes itself from sibling tools like polymarket_arbitrage by focusing on multi-venue 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?

The description details two modes (topic shortcuts and explicit tickers), explains when each is appropriate, and provides explicit warnings about compatibility and temporal alignment. It tells the agent that pre-mapped topics often return warnings, setting clear expectations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds that omitting key lists all and scoping details, but does not significantly expand beyond annotations.

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

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

Two concise sentences, front-loaded with core action, no wasted words.

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

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

For a simple retrieval tool with one optional parameter and rich annotations, the description adequately explains usage and return behavior without needing output schema.

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

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

Schema coverage is 100% and description restates the optional key parameter's behavior (omit to list all keys) without adding deeper meaning beyond schema.

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

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

The description clearly states the tool retrieves a saved value or lists keys, with a specific verb and resource, distinguishing it from siblings like remember and forget.

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

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

Describes when to use (look up stored context) and scoping (by identifier), but does not explicitly state when not to use or provide alternatives beyond mentioning pair 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 readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds valuable behavioral details: the structure of returned alerts (source, citation_uri, payload), the effect of mark_read on subsequent calls, and idempotency implied by 'polls work fine'.

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 (5 sentences), front-loaded with purpose, and every sentence adds distinct value. No filler or repetition.

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

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

Given 5 optional parameters, no output schema, and rich annotations, the description covers all needed aspects: purpose, parameter usage, return behavior, polling safety, and alternative access. It is complete for a read-only polling tool.

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

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

Schema coverage is 100%, baseline 3. The description adds meaning beyond the schema by giving an example for 'type' (sec_8k) and explaining that mark_read flags returned events read. However, not all parameters (limit, unread_only) are elaborated, so it's not a 5.

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

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

The description clearly states 'Pull fired events from your subscription feed' and specifies it returns the most recent alerts with source, citation_uri, and raw payload. The verb 'pull' and resource 'fired events' are specific, and while sibling tools exist, this tool's purpose is unambiguous.

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

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

Provides context that polls work fine and mentions an alternative HTTP endpoint for scripts/dashboards. However, it does not explicitly exclude cases where other tools should be used, lacking when-not-to-use guidance.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds details about parallel calls to multiple sources, fallback mechanisms, and API sunset, enhancing transparency beyond annotations.

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

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

Description is front-loaded with purpose and provides comprehensive details in a single paragraph. Could be slightly more structured, but is appropriately sized for the information provided.

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 covers inputs, source behavior, and alternatives. Lacks explicit return value structure but provides enough context for typical usage.

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

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

Schema covers all parameters. Description adds context: 'since' format examples and recommendation, 'value' accepts ticker or CIK, and explains 'type' is limited to 'company'. This adds meaningful usage guidance.

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 a change feed for a company in a specified time window, using specific verbs like 'get recent changes' and distinguishing from sibling tool 'entity_profile' for static profiles.

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

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

Provides explicit examples of when to use ('what's new with X') and directs to an alternative tool for static profiles. Fallback behavior is described, though lacks explicit 'when not to use' beyond that.

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 idempotentHint=true and destructiveHint=false; the description adds that storage is scoped by identifier, authenticated users get persistent memory, and anonymous sessions retain memory for 24 hours. This context is valuable beyond annotations and does not contradict 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 three sentences: first states purpose, second gives usage guidance, third details behavior. Every sentence adds value, no repetition, and the structure is front-loaded with the most important information.

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

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

For a simple tool with two string parameters and no output schema, the description fully covers purpose, usage guidelines, behavioral traits, and parameter context. It is complete and leaves no obvious 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 description coverage is 100%, with each parameter described. The description repeats the key-value pair concept but adds usage examples and scoping context. While helpful, it does not significantly add 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 'Save data the agent will need to reuse later', specifies the verb and resource, and gives concrete examples like 'a resolved ticker, a target address'. It distinguishes from sibling tools 'recall' and 'forget' by mentioning them as companions.

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 discover something worth carrying forward' and provides examples. Does not explicitly state when not to use, but implies it is for storing data that will be reused. Mentions pairing with recall and forget, which clarifies the tool's role in a workflow.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds rich behavioral context: graceful degradation of LEI/FIGI enrichment, cascading through multiple internal endpoints, labeling identifiers with source, and explicitly stating unresolved identifiers. This goes well beyond the annotations and fully informs the agent of the tool's behavior.

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

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

The description is quite long and dense, with a large block of text explaining supported types. While it front-loads with example queries and usage guidance, the later paragraphs are verbose and could be streamlined. Every sentence adds value, but the length may reduce quick scanning by an agent. A 3 reflects that it is adequate but not optimally 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 no output schema, the description provides substantial context about return values (identifiers with source, unresolved list, graceful degradation). It covers both entity types. However, it does not explicitly describe the exact JSON structure of the response, which is a minor gap. Overall, it is nearly complete for an agent to understand what the tool returns.

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 description adds significant value: for 'type', it explains what each enum value returns in detail (company vs drug, including cross-source identity spine, LEI, FIGI, etc.). For 'value', it provides multiple input formats (ticker, CIK, ISIN, name) with examples. This adds meaning far beyond the schema's terse 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 starts with concrete example queries that immediately clarify the tool's purpose: resolving names to official identifiers. It clearly states the action ('resolve a user-spoken NAME to the canonical/official identifiers') and the resource (names/entities). The supported types are detailed, distinguishing it from sibling tools that focus on research, alerts, or other tasks.

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

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

The description explicitly says 'Use FIRST whenever you have a name but need an ID', providing strong when-to-use guidance. It also mentions that using resolve_entity replaces 2-3 manual lookups, implying it's a convenience tool. It does not explicitly state when not to use or list alternatives, but the guidance is clear enough for an agent to decide.

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 readOnly, openWorld, idempotent, and non-destructive. The description adds value beyond annotations by revealing the tool probes each entity with ai_visibility_check, ranks results, and returns specific metrics (score, confidence, signal density). No contradictions; enhances transparency.

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 with no fluff. First sentence states the core action and output; second provides context, use case, and return details. Perfectly front-loaded and efficiently written.

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?

Without an output schema, the description compensates by mentioning the returned ranked list with score, confidence, and signal density. It also notes entity count constraints. It covers the tool's complexity well, though minor details like error handling or pagination are omitted. Nearly complete for the task.

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%, yet the description adds critical context: 'First entry treated as the 'subject' for narrative; rest are competitors.' and 'Omit for just workers-ai.' These semantics go beyond the schema's per-parameter descriptions, significantly improving understanding.

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

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

The description clearly states the tool's purpose: 'Compare AI visibility across multiple entities side-by-side.' It specifies the action (probe, rank, surface) and the resource (entities, AI visibility). It distinguishes from siblings like ai_visibility_check by noting it is a composite that calls that tool, and from compare_entities by focusing on AI presence.

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

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

The description provides explicit context: 'Useful for competitive AI-marketing audits: does Claude know about us as well as our competitors?' It implies when to use (comparing multiple entities) but does not explicitly exclude alternatives or mention when not to use. With clear situational guidance, it scores a 4.

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

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

Beyond the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint), the description adds rich behavioral details: it aggregates multiple external APIs, returns a specific summary block, notes that bundlephobia's first measurement can take 5-30 seconds, and indicates graceful degradation with sources_failed. 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 fairly concise given the complexity of a composite tool, but it includes some redundancy (e.g., repeating 'NPM ecosystem only'). The structure is logical: purpose, usage, returns, limitations. It could be slightly tighter but is well-organized and front-loaded.

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?

Without an output schema, the description thoroughly covers return values: summary block fields, per-advisory detail, links, alternative versions, and sources_failed for partial failures. It also addresses error handling and timing quirks (5-30s delay). Complete for a multi-source composite tool.

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

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

Schema description coverage is 100%, so the description adds limited parameter detail but does provide context: version defaults to latest, scoped packages are accepted. It also explains how parameters are used in the composite check (e.g., version determines which version to analyze). This adds value beyond the schema, justifying a 4.

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

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

The description clearly states the tool's purpose as a composite check for npm packages using deps.dev and bundlephobia. It distinguishes itself from alternatives by specifying the NPM-only scope and directing users to deps.dev for other ecosystems. The verb 'scan' and the detailed explanation make the purpose unmistakable.

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

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

The description explicitly provides usage guidelines: 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me".' It also clarifies when not to use (for non-NPM packages) and mentions partial failure handling, giving clear context for appropriate invocation.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds valuable technical details: embedding model (BGE-base-en), similarity metric (cosine), windowing (500-char overlapping), character cap (200K) with truncation flagging, and output structure (passages with offsets and scores). 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 a tight, well-structured paragraph. It leads with the core function, then usage, then output features, then pairing, then technical details. Every sentence adds value with no waste.

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

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

Despite no output schema, the description adequately explains what the tool returns (top-N passages with offsets and scores), and covers limitations (200K char cap with flagging). It also mentions integration with sibling tools, making the context complete for an agent.

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

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

Schema coverage is 100% with descriptions for all parameters. The description reinforces and enriches them: clarifies 'text' as document text, gives query examples, notes max chars and default limit. This adds contextual meaning beyond the schema, justifying a slight premium over baseline 3.

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

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

The description clearly states the tool performs semantic search inside a fetched record, with concrete examples (SEC 10-K, article, long tool result). It distinguishes itself by mentioning pairing with ask_pipeworx_grounded, making its purpose distinct from siblings.

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

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

The description explicitly advises when to use: 'Use when the record is too big to cram into the prompt — search_within saves context.' It also suggests a complementary tool (ask_pipeworx_grounded) for grounding over passages, providing clear usage guidance.

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

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

Annotations (readOnly=false, openWorld=true, idempotent=true, destructive=false) are consistent. Description adds behavioral context: account requirement, persistent feed always on, delivery channel limitations (phone verification, 10/day SMS cap, webhook auto-disable after 10 failures), and webhook HMAC signing details. 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 lengthy but every sentence adds value. Well-structured: first sentence states purpose and return, then requirements, then types with examples, then delivery channels. Could be slightly more concise but acceptable 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?

For a tool with 3 parameters (1 enum, nested objects) and no output schema, the description covers input fully with examples, explains return (subscription id), and provides behavioral constraints. No gaps for an agent to use correctly.

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

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

Schema coverage 100% but description adds substantial meaning: for 'type' lists enum values with context; for 'params' gives concrete examples for each type including optional fields; for 'delivery' explains each channel's behavior and constraints (E.164 format, verification, rate limits, webhook signing). Far exceeds 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?

Clear verb 'create' with specific resource 'proactive monitoring subscription to a live-data event stream' and return value 'subscription id'. Distinguishes from sibling tools like list_subscriptions, unsubscribe, recent_alerts.

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

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

States account requirement (Pipeworx OAuth) and that anonymous/BYO cannot persist subscriptions. Provides type-specific examples and delivery channel options. Could be more explicit about when not to use (e.g., for one-time alerts), but implied by context with siblings.

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

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

Annotations indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint are all true/false appropriately. The description adds behavioral context: it returns category-bucketed examples drawn from a 'live catalog of thousands of tools', and explains the output structure. 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 well-structured: starts with alternative phrasings, then states purpose, output details, and usage guidance. It is efficient and front-loaded, with no wasted sentences, though could be slightly more concise.

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

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

Given the tool's role as an onboarding entry point with one optional parameter and no output schema, the description is complete. It covers what it returns, how to use it (with/without topic), and when to use it first.

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 optional parameter. The description adds value by listing example topic values ('finance', 'pharma', etc.) and explaining the effect of providing or omitting it, going beyond the schema's bare description.

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

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

The description clearly states the tool is 'the onboarding entry point for an agent that just connected' and returns 'category-bucketed example questions' with exact tool+argument shapes. It distinguishes itself from siblings like 'discover_tools' by focusing on example questions for Pipeworx.

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

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

The description explicitly says 'Use this FIRST when you do not yet know what Pipeworx can do for you' and explains when to pass a topic vs omit. It provides clear context but does not explicitly state when not to use it.

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

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

Annotations already indicate this is a read-only, idempotent, non-destructive operation, but the description adds no behavioral context beyond that. It does not mention rate limits, result size limits, error behavior, or what TAP endpoint is queried, so behavioral transparency is minimal.

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

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

The description is extremely short ('ADQL TAP query') but this is under-specification rather than effective conciseness. It is a fragment without a verb, and provides no meaningful information. While it has no wasted words, it fails to serve its 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?

Despite having an output schema and well-documented parameters, the description leaves major gaps: it does not explain what data is available, what ADQL features are supported, or what TAP service is used. For a generic query tool, this is insufficient context for an agent to use it effectively.

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

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

The input schema has 100% coverage with descriptions and examples for both 'query' and 'format', so the baseline is 3. The description 'ADQL TAP query' adds no additional meaning beyond what the schema already provides, making it neutral in parameter semantics.

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

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

The description 'ADQL TAP query' is essentially a fragment that expands the tool name without specifying what data is queried or what service it accesses. It does not differentiate from sibling tools like 'planets' or 'kepler_candidates', and the purpose is only clear to someone already familiar with the domain.

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?

There is no guidance on when to use this tool versus alternatives. The description does not mention any specific use cases, exclusions, or recommend specialized sibling tools, leaving the agent without direction on scenario-based selection.

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

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

Annotations idempotentHint=true, destructiveHint=false are supplemented with context: row is deactivated (not deleted) and historical events remain. 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?

Two concise sentences, front-loaded with purpose, then constraints and side effects. 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?

Single parameter, no output schema. Description fully covers behavior, ownership, and deactivation impact. No gaps.

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

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

Schema coverage is 100%, description adds that id is a uuid returned by subscribe, providing provenance beyond schema.

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

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

Description clearly states the verb 'Cancel' and resource 'subscription by id'. It specifies ownership enforcement, distinguishing it from siblings like 'subscribe' and 'list_subscriptions'.

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

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

Explicitly states ownership constraint and when to use (cancel your own subscriptions). Mentions that the row is deactivated, not deleted, linking to 'recent_alerts' for history. No explicit when-not-to, but constraint suffices.

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

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

Beyond the read-only, non-destructive annotations, the description discloses important behavioral traits: automatic routing between SEC EDGAR/XBRL and grounded pipelines, the meaning of each verdict, and a critical warning that could_not_verify means the check did not happen and must not be treated as evidence. This is rich, non-obvious context that annotations alone do not provide.

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

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

The description is long but earns its length: it front-loads with query examples, defines the tool's purpose, explains routing logic, enumerates return values, and highlights a critical caller warning. Every sentence adds functional value, and the structure moves from general use to specific caveats.

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 is remarkably complete. It covers what the tool does, how it routes, what verdicts are returned, what citations look like, and the crucial distinction between could_not_verify and unsupported. Combined with the rich annotations and schema, the agent has enough context to invoke and interpret the tool correctly.

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

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

Schema coverage is 100%, so the description does not need to re-explain claim or tolerance_pct. The description does add algorithmic context ("exact percent-delta math", "tolerance implied by wording") but this largely mirrors what the schema already states. The baseline of 3 applies because the schema carries the parameter documentation burden.

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 natural-language examples ("Is it true that…" / "fact check") and states a specific verb+resource: verifies factual claims against authoritative sources. It clearly distinguishes itself from sibling tools by focusing on claim verification and explicitly contrasting with a structured SEC EDGAR path vs. a grounded pipeline.

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

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

It gives explicit when-to-use guidance: "Use whenever the agent needs to check whether something a user said is factually correct." It also describes how different claim types are routed. However, it does not explicitly mention when not to use this tool or name alternatives, so it misses the full when-not/alternatives criterion.

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