Biorxiv

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

Annotations already declare readOnly, idempotent, non-destructive. Description adds behavioral context: scoring range, per-model return structure, free vs. paid model usage, and that probing is straight through to Anthropic. 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?

Four tightly written sentences with front-loaded key information. No redundant phrases; every sentence adds value.

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

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

Despite no output schema, description fully explains return structure (per-model {score, confidence, signals, raw_response} + combined view). Covers all parameters and use cases adequately.

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

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

Schema coverage is 100%, so baseline 3. Description adds value beyond schema by clarifying default model, payment implications, and context disambiguation role. However, it does not add format constraints beyond what 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?

Description uses specific verb 'probe' and resource 'LLMs for what they know about a business/brand/product/topic' and uniquely scores visibility (0-100) per model. Clearly distinguishes from sibling tools like deep_research or ask_pipeworx by its focus on AI visibility auditing.

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

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

Explicitly states use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Provides guidance on when to pass _apiKey (for Anthropic) and default model. Lacks explicit when-not-to-use or comparison to sibling tools like scan_competitor_ai_presence, but context is clear.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds useful behavioral context beyond that: it routes the question, fills arguments internally, and returns stable pipeworx:// citation URIs. There is no contradiction with the annotations, and the added detail helps an agent know what to expect.

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 every sentence earns its place: scope, alternatives, trigger phrases, concrete examples, and exclusions. It is front-loaded with 'PREFER OVER WEB SEARCH', so the agent immediately knows the primary decision rule. There is no redundant filler.

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

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

For a read-only natural-language router with no output schema, the description is complete: it explains what the tool does, when to use it, what kinds of questions it handles, what it returns, and how it compares to deep_research. Nothing an agent needs to select and invoke it correctly is missing.

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

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

Schema coverage is 100%, with all six parameters documented as aliases for the single 'question' field. The description adds example query types and trigger phrases, but it does not add any syntax or format details beyond what the schema already provides. A baseline of 3 is appropriate 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 states a specific verb ('routes') and resource: it sends natural-language questions to one of 5,798 tools across 1,517 verified sources and returns structured answers with citation URIs. It clearly distinguishes the tool from web search and from the sibling tool deep_research, so an agent can tell them apart without opening schemas.

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

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

The description explicitly says 'PREFER OVER WEB SEARCH' for a long list of domains and gives trigger phrases like 'what is', 'look up', 'find', 'get the latest'. It also names deep_research as the alternative for broad multi-part questions and clarifies that breaking news is already handled by ask_pipeworx. This gives both positive and negative 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 cover the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the bar for additional behavioral disclosure is met comfortably. The description adds the critical dynamic behavior: candidate routing improvements are enabled live only when one is under test, none is active since 2026-07-26 so it currently matches ask_pipeworx exactly, and 'Falls back to nothing — this IS a full working router' removes any doubt about its operational status. This temporal variability is exactly the nuance an agent needs beyond the static 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?

Four sentences, each earning its place: identity, current live status, usage direction, and an explicit all-fallback guarantee. The key phrase 'identical universal router' is front-loaded in the first sentence so the agent immediately anchors to the known ask_pipeworx contract. Dense and informative without bloat, though it could arguably trim the retirement date detail.

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

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

Despite having no output schema, the description covers the 'same response shape' contract as ask_pipeworx, which is the essential return-value information for a universal router. It also covers the main correctness risk — the candidate state that may make behavior diverge from stable at any time — with current status and a hard guarantee that it is a full working router. For a question-routing tool, nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100%, with every one of the six parameters (q, text, input, query, prompt, question) documented as an alias for question, so the schema carries the full semantic load. The description adds only cross-tool context — 'same arguments' as ask_pipeworx — which confirms alias compatibility but does not explain the parameters themselves. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description states a specific verb and resource: a universal router identical to ask_pipeworx across 5,798 tools, with candidate routing improvements under test. It clearly distinguishes itself from the stable sibling ask_pipeworx and from ask_pipeworx_grounded, while naming the exact scope of its behavior. An agent can tell what this is and what it is not without opening any schema.

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 it exactly like ask_pipeworx when you want the newest routing,' giving a concrete when-to-use condition and naming the stable alternative as the comparison baseline. It implies the when-not-to-use case through 'experimental edge' and the beta framing, but does not state an explicit exclusion such as 'use ask_pipeworx for stable production results.' Clear context without formal 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?

The description goes well beyond annotations by detailing exact success and refusal response shapes, enumerating refusal reasons, and noting the extra LLM call cost. It also explains the grounding mechanism: the answer is extracted using only the tool result, which is a meaningful behavioral disclosure not present in the annotations.

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

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

The description is dense but every sentence earns its place: purpose, mechanism, return/refusal contract, use cases, and cost tradeoff are all included without fluff. The most important distinction, hallucination resistance, is 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?

Despite having no output schema, the description fully specifies the return shape on both success and refusal, including refusal reasons. It also supplies usage context, cost implications, and relationship to sibling tools, making the description complete for an agent selecting and invoking this 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%, and the schema already documents the question parameter and its aliases, so the description does not need to repeat parameter details. The description adds no extra parameter-level semantics, but the schema already carries the full burden, making the baseline 3 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 hallucination-resistant answer mode for high-stakes reads, with a specific verb and resource. It explicitly contrasts itself with ask_pipeworx and describes the extraction behavior and refusal cases, making its purpose unmistakable.

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

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

The description gives explicit when-to-use guidance: use whenever an answer will be quoted, cited, or acted on and facts must not be invented. It also provides a when-not-to-use signal by stating it costs an extra LLM call and that ask_pipeworx should be preferred for casual lookups.

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

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

The description extensively covers behavioral traits beyond annotations: resolution process, classifier fan-out, response structure (market, analysis, evidence), resolver contract with confidence levels, parent_event extraction, news fallback, safety short-circuits for low-confidence and closed markets, spread tradeability, and cancellation rule parsing. 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 long but well-organized with labeled sections (e.g., RESPONSE SHAPES, RESOLVER CONTRACT, PARENT_EVENT EXTRACTOR). Every sentence adds value, covering input, processing, output, edge cases, and safety. It is front-loaded with the main purpose and structured for easy scanning.

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

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

Given the tool's complexity (multiple response shapes, resolver contract, fan-out logic, safety conditions) and the lack of an output schema, the description provides exhaustive detail. It covers input variations, processing steps, output fields, edge cases, and safety mechanisms, making it fully complete for agent 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%, baseline 3. The description adds meaningful context: market parameter can take slug, URL, or question text; include_raw parameter includes guidance on when to set true (recompute deltas, cite observations). These additions go beyond the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It specifies input types (slug, URL, question text) and distinguishes from siblings by stating use cases like 'should I bet on X' and listing classifiers and fan-out examples.

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

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

The description explicitly suggests use cases ('Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z"'), providing clear context. It does not explicitly exclude alternatives or name sibling tools, but the specificity of the purpose makes the usage guidelines strong.

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 behavioral context beyond annotations by explaining data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handling of fiscal years, sorting by primary metric, and inclusion of citation URIs. It does not contradict annotations.

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

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

The description is concise and well-structured, starting with trigger phrases, then function overview, per-type specifics, sorting, and return format. Every sentence adds value, and it is front-loaded for quick comprehension.

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

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

Given the rich input schema and annotations, the description provides sufficient context: data source details, sorting behavior, and citation URIs. It does not specify exact return structure but is adequate for a comparison 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%, and the description enriches parameter meaning: for 'type', it details what each enum value retrieves; for 'values', it gives examples, constraints, and entity-specific formats. This adds significant value beyond the schema.

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

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

The description clearly states it performs side-by-side comparisons of 2-5 entities (companies or drugs) in a single call. It includes trigger examples like 'compare X and Y' and 'which is bigger', and distinguishes from siblings by noting it replaces sequential single-pack 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?

The description explicitly advises to 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It also provides specific input triggers and conditions for use, such as comparing companies or drugs.

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

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

Beyond the readOnlyHint/idempotentHint annotations, the description discloses substantial behavioral detail: it requires an account, covers only structured data, returns explicit gaps[] rather than inventing findings, provides fetchable citations, flags contradictions in standard/thorough modes, excerpts large records, and gives expected latency. This is far more transparent than the annotations alone.

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 front-loaded with the critical prerequisite and fallback tool, then proceeds from purpose to behavior to output and timing. Some details are densely packed and could be tightened, but every sentence carries substantive information for a complex 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?

With no output schema, the description thoroughly explains what a findings packet contains, how gaps and contradictions are represented, how citations work, how large records are handled, and what runtime to expect. Combined with the schema's parameter details and annotations, nothing essential is missing for an agent to invoke this tool correctly.

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

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

Schema coverage is 100%, so the schema already documents both parameters well. The description adds meaningful extra context: the 'thorough' depth requires a paid plan, and it clarifies expected runtime for each depth. For 'question', it supplies concrete examples of good queries, reinforcing the natural-language semantics.

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

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

The description clearly identifies a specific verb and resource: grounded multi-source research across Pipeworx's structured data sources in one call. It explicitly distinguishes itself from open-web search and ask_pipeworx, giving an agent a precise mental model of what deep_research does.

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

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

The description gives explicit when-to-use guidance: best for broad/multi-part questions over structured data, and for a single lookup use ask_pipeworx instead. It also states the account/plan prerequisite and names ask_pipeworx as the fallback when not signed in, so the agent knows exactly when to select this tool versus alternatives.

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

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

Annotations already document readOnlyHint, idempotentHint, etc. Description adds retrieval modes but not pagination or other behaviors beyond what annotations indicate.

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

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

Single sentence, appropriately concise. Could be slightly more structured but front-loads key purpose.

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

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

Given output schema exists, not required to detail returns. However, misses stating mutual exclusivity of DOI and date, and doesn't mention pagination despite cursor parameter.

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 3. Description aligns with schema but adds no extra meaning beyond summarizing the two retrieval methods.

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

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

Description clearly states it retrieves preprint metadata by DOI or date/date range. It's specific and distinguishes from siblings like 'published' or 'summary', though it could explicitly differentiate.

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

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

No guidance on when to use this tool vs alternatives. Does not mention prerequisites or appropriate contexts.

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

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

Annotations (readOnlyHint, idempotentHint) already indicate safety and idempotency. The description adds value by specifying the return format: 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly.' No contradiction with annotations.

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

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

Description is a single paragraph but efficient. It front-loads the purpose and then provides key details. Could be slightly more structured, but it's clear and 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 the tool's simplicity (discovery), the description covers core functionality, return format, and best practice to call first. No output schema but description explains the return content. Minor gaps (e.g., caching behavior) but adequate overall.

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 6 parameters with descriptions. Description explains 'query' accepts natural language and lists aliases, and mentions 'limit' default 20, max 50. This adds context beyond the schema but is not essential since schema is already comprehensive.

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 function: 'Find tools by describing the data or task.' It lists specific domains and contrasts with sibling tools by indicating it should be called first for browsing the option set. This distinguishes it from task-specific 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?

Explicit guidance on when to use: 'Use when you need to browse, search, look up, or discover what tools exist for:' with domain examples. Also says 'Call this FIRST...' implying precedence over other tools. No explicit exclusions, but context is clear.

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

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

Annotations already establish read-only, open-world, idempotent, and non-destructive behavior, so the description's burden is to add context beyond that. It does so extensively: the tool fans out across many sources in parallel, soft-fails on the USPTO sunset, reports sources_used/sources_failed, and clarifies that empty sections represent real 'no data' rather than bugs. This is rich, honest behavioral disclosure with no contradiction to 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 long but dense, with every major sentence adding operational detail about sources, return sections, or failure behavior. It is front-loaded with example intents and the core purpose before diving into source enumeration. There is minor redundancy in restating type interchangeability that the schema already covers, but no real filler.

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

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

With no output schema, the description carries full responsibility for explaining the return envelope, and it does: it enumerates resolved fields, recent_filings, fundamentals, patents, federal_contracts, fda_products, hiring, news, LEI, and sources_used/sources_failed. It also documents input forms, name resolution, private-company behavior, soft-failure modes, and expected empty results, making the tool safely invocable by an agent.

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

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

The schema already documents both parameters fully, with 100% description coverage. The description adds meaningful semantic context: value can be a ticker, zero-padded CIK, or company name; names resolve via SEC EDGAR; and type accepts 'company' or 'ticker' interchangeably. This goes beyond the schema by explaining resolution behavior and private-company failure 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 opens with concrete example intents and immediately states that the tool produces a 'full cross-source profile of a US public company in ONE parallel call.' It distinguishes itself from chaining single-pack SEC/XBRL/news lookups and enumerates the specific sources and output sections it returns. This makes it unambiguous what the tool does and how it differs from simpler 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?

The description gives an explicit trigger: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also explains expected edge conditions, like private companies returning resolved:false and empty fda_products being normal. However, it does not name sibling tools such as deep_research or details as alternatives, so the guidance is clear but not exhaustive.

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

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

Annotations already indicate destructiveHint=true and idempotentHint=true. The description confirms the destructive behavior ('Delete') but does not add details beyond what annotations provide, such as retention or undo 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 two sentences, front-loading the verb and resource, with no unnecessary words. Every sentence serves a purpose.

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

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

For a simple tool with one required parameter and no output schema, the description fully explains purpose, usage context, and pairing with sibling tools. It is complete and actionable.

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

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

Schema coverage is 100%, so the description adds minimal value over the schema's parameter description ('Memory key to delete'). The description's phrase 'by key' is redundant with 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 'Delete a previously stored memory by key,' which includes a specific verb and resource. It distinguishes from siblings like 'remember' and 'recall' that are listed in the sibling tools.

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

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

The description provides explicit scenarios for use (stale context, task done, clear sensitive data) and suggests pairing with remember and recall. However, it does not explicitly state when not to use the tool, which would strengthen guidance.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. The description adds value by explaining the process: fetches page, extracts title/description/key links, emits standard markdown format, and output is a single text blob ready for deployment. 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 a single, well-structured paragraph. It starts with the main purpose, then details the process, and ends with use cases. Every sentence adds value with no redundancy or fluff.

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

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

For a simple tool with 2 parameters and no output schema, the description fully covers purpose, operation steps, output format, and use cases. It provides sufficient context for an AI agent to decide when and how to use it.

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

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

Schema has 100% coverage with descriptions. The description adds context beyond schema: url can be a specific landing page, max_links default and max values are stated. This helps agents understand parameter meaning and constraints.

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

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

The description clearly states the verb 'generate', the resource 'llms.txt file', and the target 'any URL'. It lists specific use cases (client's site indexing, drafting, auditing competitor) that distinguish it from siblings like 'ai_visibility_check' and 'scan_competitor_ai_presence'.

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

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

Provides explicit use cases for when to use the tool (getting a client's site indexed, drafting, auditing). However, it does not mention when not to use it or suggest alternatives among siblings, which would be beneficial.

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, so the tool is understood as safe. The description adds transparency by listing the exact return fields, which helps the agent understand what to expect 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 succinct with two sentences, no filler. It front-loads the purpose and includes a usage guideline, earning 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's simplicity (one optional parameter, no output schema), the description is complete. It explains return fields, usage context, and the parameter. 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%, so the parameter 'include_inactive' is fully described in the input schema. The description does not add extra meaning to the parameter beyond what the schema already provides, meeting the baseline.

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

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

The description clearly states the tool lists active subscriptions and specifies the returned fields (id, type, params, created_at, last_fired_at, fire_count). It distinguishes from siblings like subscribe and unsubscribe by focusing on listing.

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

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

The description explicitly tells when to use the tool: to review monitoring before adding more subscriptions or to find an ID to cancel. It does not mention when not to use it, but the use cases are clear and practical.

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 minimal (all false), so the description carries the burden. It discloses rate limiting ('Rate-limited to 5 per identifier per day'), token-based follow-up ('Filing without an account returns a claim_token... pass it back later'), and operational impact ('team reads digests daily... signal directly affects roadmap'). It also clarifies it is free and not quota-consuming. 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 longer than average, but every sentence adds value: purpose, when-to-use, exclusions, token mechanism, rate limit, quota note. It is front-loaded with the core purpose and structured logically. No fluff or redundancy.

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

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

For a feedback tool with no output schema, the description explains what the user should expect (claim_token, later status/change details). It covers scope, usage, exclusions, and operational constraints. It is complete for the task of configuring and invoking the tool correctly, including the edge case of follow-up via token.

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

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

Schema covers 100% of parameters, but the description adds substantial semantics: it maps 'type' enum values to concrete scenarios (bug/feature/data_gap/praise), explains the 'claim_token' parameter's usage with a code example, and advises on 'message' content ('don't paste the end-user's prompt'). This goes far beyond schema descriptions.

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

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

The description clearly states the tool's purpose: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It uses a specific verb (tell/send), resource (Pipeworx team), and explicitly distinguishes itself from sibling tools by limiting scope to 'tools served by this Pipeworx connection' and clarifying it is not for other MCP servers. This fully differentiates it from ask_pipeworx or research tools.

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

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

The description provides explicit when-to-use guidance: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise).' It also gives a clear exclusion: 'if the tool came from a different MCP server... file it with that server instead.' This is exemplary contextual guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds valuable details: data source (CF analytics-engine), privacy (no PII), schema (pack, tool, count), and caching behavior (5min-1h). This fully discloses 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?

The description is three dense sentences. First sentence states output and options. Second sentence lists use cases in a numbered format. Third sentence provides technical background. No fluff; every sentence earns its place.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description covers what is returned (top tools, packs, call volume) and the data source. It does not specify the exact response structure (e.g., fields or limits), but given the tool's simplicity and annotations, it is sufficiently complete.

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

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

Schema coverage is 100% with enum and description. The description adds context: 'Shorter windows surface what's hot right now; longer windows show steady-state demand.' This clarifies the semantic difference between values, going beyond the schema's mere listing.

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 returns 'top tools, top packs, and total call volume' over a selectable time window. The verb 'returns' and the specific resource list make the purpose unambiguous. It distinguishes itself from sibling tools like discover_tools or ask_pipeworx by focusing on trending/aggregate data.

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

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

Three concrete use cases are listed (discovering hot data sources, confirming canonical choice, checking alignment). The description also explains the trade-off between short and long windows. It lacks explicit 'when not to use' guidance, but the use cases are clear enough for most agents.

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 behavior beyond annotations, including monotonicity checks, partition sum validation, fill check logic, semantic anchor for cross-event matching, and partition filter for placeholder slugs. No contradiction with annotations (readOnly, openWorld, idempotent, non-destructive).

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

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

The description is detailed and informative but somewhat verbose, with some repetition (partition check explained twice). It front-loads the core function but buries fill check and semantic anchor details. Could be more concise while retaining clarity.

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

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

Given the tool's complexity (multiple modes, fill check logic, no output schema), the description is highly complete. It describes the response structure, edge cases (low similarity, placeholder fraction), and recommends sibling tools, leaving no major 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 descriptions already cover both parameters thoroughly (100% coverage). The description adds value by explaining the behavioral implications of each parameter (e.g., how event slug triggers partition_check) and providing usage examples, but does not introduce major new semantics beyond the schema.

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

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

The description clearly states the tool's purpose: finding arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes three modes (no args, event, topic) and provides examples, clearly separating it from sibling tools like polymarket_edges and polymarket_fill_risk.

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

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

Explicit guidance is given for when to use each parameter: no args for trending scan, event for specific market, topic for cross-event scanning. It also warns when not to trade (if realizable_edge_pp <= 0) and suggests an alternative tool (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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive. The description adds substantial behavioral context: caching at KV level keyed on knobs, tradeable-edge filters, diagnostic info like _diagnostics{concentrated_longshot}, and explanations of how model families work. 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 long but well-structured with bold headers (FIVE MODEL FAMILIES, TRADEABLE-EDGE KNOBS, RESPONSE TOP-LEVEL). It is front-loaded with the core purpose. Some technical details could be streamlined, but the length is justified given no output schema.

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

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

Given 9 parameters, no output schema, and sibling tools, the description covers response structure (by_segment, diagnostics), caching behavior, edge cases (empty segments, Fed bets), usage of knobs, and model details. It leaves little ambiguity for an agent to understand when and how to invoke.

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 thorough parameter descriptions. The description adds value by grouping parameters into 'TRADEABLE-EDGE KNOBS' (min_liquidity, max_spread_pp) and explaining high-level purpose (e.g., 'Set to 2 to require tight books'). It also explains the effect of min_kelly and min_partition_leg_kelly in 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 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price', with a specific verb and resource. It adds 'Built for "what should I bet on today"' and distinguishes itself from siblings by detailing model families (crypto_price, news_momentum, partition_overround, concentrated_longshot) and tradeable-edge knobs.

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 'Built for "what should I bet on today"' and describes when segments are empty and why. It implies use for opportunity discovery rather than full market listing. However, it does not explicitly list when not to use or compare directly to sibling tools like polymarket_arbitrage.

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

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and non-destructive. The description adds behavioral details: reads from daily snapshots, 60-day TTL, decay computed from daily closes not intraday. 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 yet comprehensive, with a clear structure: purpose, arguments, response details (tracked, expired, snapshot_dates), and limitations. Every sentence adds value and is 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?

Given the complexity and no output schema, the description fully covers the response fields, including edge_pp_net signing, trend categories, decay rate, and expired opportunities. Limitations are stated, making the tool's usage complete.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value by explaining default values, clamping for days, and window family choices, and also describes the response structure.

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

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

The description clearly states the tool's purpose: providing edge persistence and decay telemetry from snapshots. It answers a specific question about edge longevity and distinguishes itself from sibling tools like polymarket_edges (current edges) and polymarket_arbitrage.

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

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

The description explains when to use the tool (to assess if an edge is fresh or old) but does not explicitly state when to use alternatives. However, the context implies that for current edges, one might use polymarket_edges.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds that it walks the ladder and returns top_of_book, vwap_fill_price, slippage_pp, etc. It does not contradict annotations, and the added detail enriches transparency 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 relatively long but well-structured with clear sections for mode selection, single-market details, basket details, and usage directives. It is front-loaded with the requirement to use one of market or event, and every sentence adds value. Minor trimming possible but not necessary.

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 explicitly lists many return fields (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict, and for basket: theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill, thin_legs, etc.). It also covers failure modes (thin legs, forced directional risk), making it complete for decision-making.

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

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

Schema coverage is 100% and description adds context: side defaults and behavior, single-market vs basket mode requirement, size_usd interpretation (spend vs target proceeds vs settlement notional). This adds meaning beyond the schema's basic descriptions.

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

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

The description clearly states it performs a risk check comparing realizable vs theoretical edge on Polymarket CLOB order books. It distinguishes two modes: single-market (with specific fields) and basket (with different return fields), making its purpose unambiguous.

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

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

Explicitly instructs to use this before acting on polymarket_arbitrage signals or polymarket_edges trades above ~$500. Warns that theoretical overround on thin books is not capturable and that partial basket fills convert arb into directional risk, providing strong when-to-use and 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?

Beyond the readOnly/idempotent annotations, the description details matcher behavior, compatibility codes, skipped-leg counters, per-leg flags, unclassified-leg exclusion, fee treatment, and the fact that returned pairs are keyword-matched rather than source-verified. This is exactly the behavioral context needed to interpret results safely.

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 it is structured with clear labeled sections (TWO MODES, RESPONSE, SAFETY FIELDS, Codes) and front-loads the core purpose and the key caveat about equivalent bet shapes. Minor redundancy such as repeated 'in EITHER mode' phrasing keeps it from being perfectly lean, but each major point earns its place.

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

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

With no output schema, the description carries the full burden of explaining return values, and it does so thoroughly: spread direction (Kalshi − Polymarket), safety fields, machine-readable codes, per-entry flags, skipped categories, temporal alignment semantics, and the gross-vs-net fee limitation. An agent has enough context to invoke the tool and interpret both success and warning outcomes.

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

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

The input schema already covers all three parameters at 100%, and the description adds meaningful semantics: it enumerates the topic values, clarifies that explicit ticker/slug override their topic-mapped counterparts, and states that both modes run the same matcher. It stops short of specifying valid combinations or required pairing rules for explicit mode, but the schema and examples cover most of that.

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

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

The description opens with a specific verb and resource: it computes the cross-venue spread between Kalshi and Polymarket for the same resolving question. It is clearly differentiated by venue pair and outcome scope, but it never names or contrasts a sibling such as polymarket_arbitrage, so it misses the explicit sibling differentiation that would earn a 5.

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 clearly explains the two invocation modes (topic shortcuts vs. explicit ticker/slug) and warns that most pre-mapped topics currently return compatibility warnings, so the agent knows when not to trust the shortcut. However, it gives no explicit guidance on when to prefer a sibling tool like polymarket_arbitrage or bet_research, so the 'vs alternatives' component is absent.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds that the tool filters preprints by published status, but does not explain pagination (cursor) or other behaviors.

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

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

Single sentence, concise but lacks structure. Does not front-load key information or organize content for quick scanning.

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

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

Despite having an output schema, the description is minimal and does not cover parameter usage or result context. Incomplete for effective tool usage.

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

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

Schema coverage is 0%, and the description provides no explanation of any parameter (cursor, server, date_or_range). The agent receives no guidance on parameter meaning or format.

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

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

Description identifies the resource (published preprints) but lacks a verb specifying the action (e.g., search, list). It's a noun phrase, making the exact operation ambiguous. It also does not differentiate from sibling tools.

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

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

No guidance on when to use this tool versus alternatives like search_within or details. No prerequisites or context provided.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds that it retrieves preprints published by a prefix, but lacks details on pagination, rate limits, or data freshness. Adequate given annotations.

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

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

Single concise sentence, but lacks structure and fails to front-load key usage details. No bullet points or clear parameter mapping.

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

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

Tool has 4 parameters, 3 required, and cursor for pagination. Description omits important context like date range format, server options, and pagination behavior. Output schema exists but still incomplete.

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 only 25% (only prefix described). The description only mentions prefix via example, leaving server, date_or_range, and cursor unexplained. Insufficient compensation for low schema coverage.

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

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

The description clearly states the tool retrieves preprints published by a given DOI prefix, with an example. It implies a specific resource but does not explicitly differentiate from the sibling tool 'published'.

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

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

No guidance on when to use this tool versus alternatives like 'published' or other search tools. No when-to-use or when-not-to-use information.

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, destructiveHint, and idempotentHint as true/false appropriately. The description adds useful behavioral context: scoped to identifier, behavior when key is omitted (list all keys), and pairing with remember/forget. This complements the annotations well without contradiction.

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

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

Two sentences: first covers the core functionality, second provides use cases, scope, and related tools. No unnecessary words, every sentence adds value. Excellent conciseness.

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

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

For a simple tool with one optional parameter and no output schema, the description covers purpose, usage, scope, and related tools. It does not detail the return format when listing keys, which is a minor gap, but overall adequate.

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

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

Schema coverage is 100% and the schema explains the key parameter and its omission. The description reinforces this by stating 'omit the key argument' and provides examples of what keys might contain (ticker, address, notes), adding value beyond the schema.

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

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

The description clearly states the verb 'Retrieve' or 'list' (when key omitted) and the resource 'value previously saved via remember' or 'saved keys'. It distinguishes from sibling tools like remember and forget by explicitly naming them and describing their pairing. Examples of stored data (ticker, address, research notes) add specificity.

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

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

The description tells when to use: 'to look up context the agent stored earlier' and to avoid re-deriving information. It also mentions pairing with remember and forget, implying alternatives. However, it does not explicitly state when not to use, which would push to a 5.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint. The description adds useful behavior context: mark_read flag affects subsequent calls, and return fields like source, citation_uri, raw payload are described. No contradiction with annotations.

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

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

The description is a single paragraph, front-loaded with the main purpose. Every sentence adds value—purpose, return fields, filtering options, behavior toggle, and alternative access method. 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 read-only polling tool with 5 parameters and no output schema, the description adequately covers return values and usage context. It mentions an alternative endpoint, which is helpful. Minor gap: no mention of pagination beyond the limit parameter.

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. The description adds significant context: explains the effect of mark_read, clarifies filtering by type and since, and mentions default limit of 50. This enriches the schema's minimal descriptions.

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

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

The description clearly states 'Pull fired events from your subscription feed' with specific verb and resource. It distinguishes itself from sibling tools like list_subscriptions by focusing on events, but does not explicitly differentiate from similar 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 mentions polling and provides an alternative URL for scripts, implying when to use the tool interactively vs. direct API. However, it lacks explicit guidance on when to use this tool over siblings or when not to use it.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint. The description adds significant detail: data sources (SEC EDGAR, GDELT→GNews fallback, USPTO), fallback logic, soft-fail behavior, and return format (changes grouped by source, total_changes count, citation URIs). No contradictions.

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

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

The description is dense but front-loaded with common use cases. It efficiently packs multiple pieces of information into one paragraph, though slightly less structured than ideal.

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

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

Given the tool's complexity (multiple data sources, fallback, soft-fail, no output schema), the description is complete. It explains the return structure, parameter details, and when to use alternatives.

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

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

Schema coverage is 100%, but description adds context beyond schema: explains `since` with examples like '7d', '30d', '3m', '1y' and suggests typical monitoring value; clarifies `value` accepts ticker or CIK; notes `type` currently only supports 'company'.

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 change feed for a company over a recent window, with examples like 'What's new with X'. It explicitly distinguishes from sibling 'entity_profile', which gives 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?

The description provides explicit when-to-use guidance with example queries and explicitly contrasts with 'entity_profile' for static needs, stating 'Use entity_profile instead when you want the static profile'.

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

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

Annotations provide idempotent and non-destructive hints. The description adds valuable behavioral context: persistence details (authenticated users persistent, anonymous 24h), scoping by identifier, and pairing with other tools. 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 a single paragraph but well-structured: purpose first, then usage guidance, then technical details. It is concise without being terse, though slightly verbose in listing examples.

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

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

Given the simple parameter set (2 strings) and no output schema, the description provides sufficient context: persistence, scoping, and relationship to sibling tools. It is complete for the tool's complexity.

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

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

Schema describes both parameters with 100% coverage. The description adds meaning beyond schema by providing key examples and value type ('any text'). It reinforces the intended usage patterns.

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 purpose: 'Save data the agent will need to reuse later'. It specifies the action (save), resource (key-value pair), scope (conversation/sessions), and provides concrete examples. It distinguishes from sibling tools recall and forget.

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

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

The description explicitly says when to use ('when you discover something worth carrying forward') and provides examples. It also mentions pairing with recall and forget. However, it does not explicitly state when not to use, but the context is clear.

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

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

Annotations already declare readOnly/openWorld/idempotent/non-destructive, lowering the bar. The description still adds substantial behavior: cross-source identity spine, graceful degradation when GLEIF/OpenFIGI are unavailable, explicit `unresolved` fields rather than omission, `figi_candidates` when a name is ambiguous, and source-labeling of identifiers. This is rich, non-obvious behavior that goes well beyond the annotations.

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

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

The description is long and dense, but nearly every clause carries useful information and it is front-loaded with examples and a clear usage directive. It is less tight than ideal, with some rambling clauses, but it is organized into recognizable sections (examples, usage, supported types, degradation) and has 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?

There is no output schema, so the description must carry the burden of explaining return semantics. It does this well for the key cases: CIK, ticker, LEI, FIGI, RxCUI, `unresolved`, `figi_candidates`, and source labels. It does not provide a complete output shape, but for a tool this complex and with only two simple parameters, the description is sufficiently complete for an agent to call it correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds valuable parameter semantics beyond the schema, especially the warning to pass the entity name only and not the full noun phrase, with a concrete bond-issuer example. It also clarifies how `type` interacts with lookup behavior, which meaningfully helps an agent construct correct calls.

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 triggers and states the core purpose: resolving a user-spoken name to canonical identifiers other tools require as input. It distinguishes the tool from siblings by naming what it replaces (2-3 manual lookups) and by covering multiple entity types, so an agent can identify when this is the right 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 gives explicit guidance: 'Use FIRST whenever you have a name but need an ID.' It clearly implies when to call this tool, but it does not explicitly state when not to use it or name alternative sibling tools it should be preferred over. That leaves some ambiguity, but the trigger condition is strong.

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

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

Annotations (readOnlyHint, etc.) are confirmed by the description, which adds details about probing with ai_visibility_check, ranking, and return format including score, confidence, signal density. No contradictions.

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

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

The description is concise (three sentences), front-loaded with the core action, and every sentence adds value. No wasted words.

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

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

Despite no output schema, the description explains return values (ranked list with score, confidence, signal density). It covers parameters, usage context, and behavior fully for a comparison 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 value by noting the first entity is a 'subject' and explaining optional models. It enriches meaning without repeating 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 states the verb 'Compare' and resource 'AI visibility across multiple entities', and distinguishes from siblings like ai_visibility_check by mentioning side-by-side comparison. It also gives a concrete use case.

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

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

The description provides a clear use case ('competitive AI-marketing audits') and notes the first entity is treated as subject. It does not explicitly state when not to use or mention alternatives, but context is strong.

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

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

Annotations already mark it as read-only, open-world, idempotent, non-destructive. The description adds depth: it fans out across two external APIs, returns specific fields (is_latest, license, advisory_count, bundle sizes, dependency_count, has_esm, tree_shakeable), and explains graceful degradation (sources_failed lists timeouts). No contradiction.

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

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

The description is dense but well-structured: first sentence is the hook, followed by return fields, ecosystem scope, and failure behavior. At ~100 words, every sentence earns its place, though it could be slightly shorter.

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 composite tool with no output schema, the description fully specifies return structure (summary block, per-advisory detail, links, alternative versions) and edge cases (scoped packages, version default, partial failures, timing). 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%, so baseline is 3. The description adds value by clarifying that scoped packages are accepted and that version defaults to latest when omitted—information not in 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 starts with a clear verb-resource pair ('should I add this npm package'), immediately conveying a composite check combining deps.dev (license, advisories, version history) and bundlephobia (size, dependencies, ESM). This specificity distinguishes it from sibling tools like 'validate_claim' 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?

Explicitly states 'Use whenever an agent asks "is X safe / popular / small"' and gives alternatives for non-NPM ecosystems ('PyPI / Maven / Cargo / Go fall under deps.dev:version directly'). Also warns about partial failures and timing (5-30s for new versions).

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint false. The description adds key behavioral details: BGE-base-en embeddings, cosine over 500-char overlapping windows, 200K char limit with truncation and flagging, and that each passage includes character offsets for verification.

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 core purpose. Every sentence adds essential information without redundancy or fluff.

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

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

Despite no output schema, the description fully explains the return format (top-N passages with offsets and similarity scores) and technical limitations (BGE embeddings, character cap). 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 description coverage is 100%, but the description adds value by providing natural-language query examples and explaining the offset feature. It does not add new parameter constraints 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 performs semantic search inside a fetched record, with specific examples like SEC 10-K body or article. It distinguishes itself from siblings by emphasizing that it saves context and pairs with ask_pipeworx_grounded.

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

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

Explicitly states when to use: when the record is too large for the prompt. Provides an alternative tool pairing (ask_pipeworx_grounded) for grounding over passages. No confusion about 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 indicate mutation (readOnlyHint=false), idempotent, non-destructive. The description adds: requires OAuth, webhook secret returned once, auto-disable after 10 failures, delivery limits. No contradictions.

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

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

Description is well-structured with front-loaded purpose. It is relatively long but every sentence adds value, with minimal fluff. Could be slightly more concise but still 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?

Covers all essential aspects: requirements, types, parameters, delivery options, return (subscription id), and failure behavior. No missing information despite lack of 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 has 100% coverage, but description adds significant context: explains each enum value with examples, details params for each type, and elaborates on delivery channels including verification and limits.

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: 'Create a proactive monitoring subscription to a live-data event stream. Returns the new subscription id.' It specifies the verb (create), resource (subscription), and distinguishes from sibling tools like list_subscriptions and unsubscribe.

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

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

The description provides explicit guidance: requires a Pipeworx OAuth account, lists supported types and their parameters, and explains delivery channels. It mentions alternatives like recent_alerts and the registry endpoint. While it doesn't explicitly state when not to use, it gives sufficient context.

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

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

Annotations already declare readOnly, openWorld, idempotent, and non-destructive. The description adds behavioral context: returns live examples from a catalog, and is safe to call without side effects. It does not contradict annotations.

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

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

The description is front-loaded with trigger phrases and purpose, followed by return details and usage instructions. It is slightly verbose due to multiple trigger examples, but each part earns its place.

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

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

Without an output schema, the description fully covers the return format: category-bucketed example questions with tool+argument shapes. It also explains when and how to use the tool, making it complete for an onboarding tool.

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

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

Schema coverage is 100%, but the description adds value by explaining the default behavior (no arguments for full spread) and providing example topics ('finance', 'pharma'), which the schema does not give.

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: returning category-bucketed example questions with tool+argument shapes. It distinguishes from siblings by positioning itself as an onboarding entry point, unlike ask_pipeworx which is a meta-tool for answering queries.

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 this tool: 'Use this FIRST when you do not yet know what Pipeworx can do for you'. It also explains how to call meta-tools after and provides options for topic focus vs. full spread.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds domain-specific context (bioRxiv only, no medRxiv endpoint) beyond what annotations provide, clarifying scope and limitations without contradicting them.

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

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

The description is extremely concise: two sentences, no fluff. The first sentence states the purpose, the second provides parameter details and domain restriction. Every word earns its place.

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

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

With only one parameter, 100% schema coverage, and an output schema present, the description covers all necessary information: what the tool does, how to configure it, and its scope. 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 description coverage is 100%, and the parameter description in the schema ('"m" (monthly, default) or "y" (yearly)') is identical to what is in the tool description. Therefore, the description adds no new meaning to the parameter. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool returns 'bioRxiv submission/publication counts', specifying the resource (bioRxiv) and action (counting). While the exact scope of 'submission/publication' is slightly ambiguous, it distinguishes from medRxiv. The title 'Summary' is vague, but the description compensates.

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 explains the interval parameter values and default, and notes that the tool works only for bioRxiv (not medRxiv), guiding when to use it. It does not compare against sibling tools, but given the context, that is not necessary.

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

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

Discloses that the row is deactivated not deleted, and historical events remain via 'recent_alerts'. Adds value beyond annotations which indicate non-destructive 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?

Two concise sentences covering function, ownership, and behavioral outcome with no redundant words.

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

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

Complete for a simple tool: covers what it does, ownership, and effect on data. No output schema needed.

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

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

Single parameter 'id' with schema description already present. Description does not add new semantics beyond the schema, which has full coverage.

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

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

Clearly states 'Cancel a subscription by id', specifying the verb and resource. Distinguishes from sibling tools like 'subscribe' and 'list_subscriptions'.

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

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

Explicitly mentions ownership enforcement ('you can only cancel your own subscriptions'), guiding when to use. Does not explicitly state alternatives, but context is sufficient.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description discloses critical behaviors: the verdict set, the difference between 'could_not_verify' (pipeline failure, not evidence) and 'unsupported' (no source exists), and the structured vs grounded routing. It also explains the tolerance override. This adds substantial context beyond annotations, 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 dense but every sentence earns its place; it front-loads user phrases and covers purpose, routing, return values, and caveats. It is somewhat long for a tool description, but the complexity justifies it. A slight trim could improve conciseness, but structure is clear.

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

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

Given the tool's complexity and no output schema, the description is remarkably complete: it explains return verdicts, evidence with citations, reasoning, and the critical distinction between 'could_not_verify' and 'unsupported'. It also notes efficiency gains. The annotations cover safety, and the description fills all other contextual 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?

Even though schema coverage is 100%, the description adds significant meaning: it clarifies that tolerance_pct overrides the wording-implied tolerance, caps at 5, and suggests set 1–2 for hallucination detection. The claim parameter is enriched with concrete examples. This goes well beyond the schema's basic field descriptions.

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

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

The description clearly states the tool's purpose: natural-language claim verification against authoritative sources, with specific example queries ('Is it true that…', 'fact check'). It distinguishes itself from siblings by explaining it replaces 4–6 sequential calls and by detailing the two-path approach (SEC EDGAR for company-financial claims, grounded pipeline for anything else), making it unique among the sibling tools.

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

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

The description explicitly says when to use: 'Use whenever the agent needs to check whether something a user said is factually correct.' It differentiates company-financial vs other claims. It doesn't name specific sibling alternatives, but mentions it replaces sequential calls, giving clear context. Lacks an explicit 'do not use when' exclusion, hence a 4.

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