Arcgis Eastbatonrouge

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

Beyond annotations, the description adds key behavioral details: the default model is free, probing Anthropic requires a BYO key with direct costs, and the return structure includes per-model fields plus a combined view. These complement the readOnlyHint and idempotentHint 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?

Three sentences, front-loaded with the primary function, efficient and information-dense. Every sentence earns its place: what it does, default behavior and key parameter nuance, plus return and use cases.

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

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

The description is complete for a tool with rich annotations and full schema coverage: it explains the purpose, default behavior, BYO key cost nuance, return shape (since no output schema exists), and relevant use cases. Minor gap: doesn't mention any limitations or model count variability, but adequate.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning by naming the default model (Workers AI Llama-3.3-70b) and clarifying the cost implication of _apiKey, which goes slightly beyond the schema's technical notes.

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 a specific verb (probe), resource (LLMs), and outcome (visibility score per model 0-100). It distinguishes itself from sibling tools like ask_pipeworx by focusing on what models know and scoring it, rather than just querying.

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

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

The description provides explicit use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. However, it does not mention when not to use it or name specific alternatives, so it stops short of a 5.

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

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, and the description is fully consistent with them — no contradiction. The description adds value beyond annotations by disclosing that it auto-routes and fills arguments on the agent's behalf and that answers carry citation URIs. It doesn't mention rate limits, latency, or failure modes, but the annotation coverage lowers the bar.

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

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

The description is well front-loaded — the headline decision, domain list, and triggers come first — but the later paragraphs repeat sibling-routing advice (ask_pipeworx_grounded and deep_research are each introduced twice) and the sentence 'step up only when needed' is awkwardly worded. It is informative but could be tightened by ~20-30% without losing content.

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 high-complexity tool with no output schema, the description covers scope, trigger phrases, exclusions, sibling routing, and return format (structured answer with citation URIs). Minor gaps: what happens when routing finds no source, response format details, and any limits are unspecified. These are secondary given the strong usage guidance.

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%: the question parameter is described and all five aliases (q, text, input, query, prompt) are labeled 'Alias for question.' The description adds trigger phrases and examples that inform how to phrase queries, but no parameter-level detail beyond the schema. Baseline 3 applies since 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?

States a specific verb+resource: it routes a natural-language question to the right one of 5,798 tools across 1,517 verified sources and returns a structured answer with stable pipeworx:// citation URIs. It also distinguishes itself from siblings explicitly (ask_pipeworx_grounded for reasoning over retrieved documents, deep_research for fan-out, web_search for ordinary browsing), so an agent can tell it 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 is unusually explicit: it front-loads 'PREFER OVER WEB SEARCH,' lists concrete trigger phrases and domains, gives six examples, states exclusions ('Do NOT use for: casual/general web browsing, image search, social media posts'), and routes to named alternatives for specific conditions (grounded reasoning, multi-part fan-out). Little is left to inference.

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

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

The description adds transparency by disclosing it is a beta/experimental edge, that behavior currently matches ask_pipeworx exactly, that it falls back to nothing (it's a full working router), and that no candidate is active as of a specific date. This goes beyond the annotations by revealing the dynamic experimental nature and the comparison workflow. Annotations already provide read-only/idempotent safety, so the bar is lower, but this is still genuinely informative.

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

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

The description is moderately concise and front-loads the beta status, then explains the current equivalence to ask_pipeworx and the experimental purpose. It's a bit verbose with the parenthetical details, but every sentence earns its place by explaining the routing comparison and fallback behavior. Reasonably structured for a tool with a complex relationship to its sibling.

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 and a simple single-required-parameter input, the description is complete enough: it clarifies what the tool does, how it relates to ask_pipeworx, and what to expect behaviorally. It could mention the response shape more explicitly, but it already says 'same response shape' as ask_pipeworx. The dynamic 'candidate improvements' context is useful for understanding potential behavior changes.

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 description mentions 'same arguments' refer to ask_pipeworx. The schema itself documents all aliases. However, the description doesn't add extra semantic detail about the question parameter beyond what the schema states, so it meets the baseline of 3 for high 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 that this is a beta variant of ask_pipeworx, a universal router with the same tools, arguments, and response shape. It distinguishes itself from ask_pipeworx by emphasizing the experimental routing improvements. However, it doesn't fully explain what the universal router does beyond routing questions, relying on the sibling name for that context.

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

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

The description provides explicit guidance: use it like ask_pipeworx when you want the newest routing, and notes that results are compared against the stable router. It also clarifies that no candidate is active right now, so behavior matches ask_pipeworx exactly. This gives an agent clear context on when to choose it, though it doesn't explicitly say 'when not to use it' beyond the beta aspect.

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

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

Beyond annotations for read-only and idempotent behavior, the description details the exact success return shape, the explicit refusal reasons, evidence as a verbatim quote, and the extra LLM call cost. This is rich behavioral disclosure that goes well beyond what annotations already offer.

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 format, use cases, and cost tradeoff. It is front-loaded with the most critical differentiator and contains no filler.

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

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

For a tool with no output schema, the description fully specifies both success and refusal response shapes, explains the grounding mechanism, and gives cost-based selection guidance. An agent has everything needed to decide when to invoke it and what to expect.

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 aliases for the question parameter are fully documented, so the schema carries the parameter semantics. The description does not add parameter-level detail, but none is needed given full 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 opens with 'Hallucination-resistant answer mode for high-stakes reads' and clearly states the tool 'EXTRACTS the answer using ONLY what the tool result contains.' This distinguishes it from ask_pipeworx and ask_pipeworx_beta while giving a specific, actionable purpose.

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 whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' and directly names the alternative: 'prefer ask_pipeworx for casual lookups.' This gives both 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?

Annotations already declare readOnly/openWorld/idempotent, and the description adds extensive context: resolver contract with market_match_confidence, low-confidence short-circuit suppressing analysis, closed-market handling, news fallback behavior, and cancellation-rule risk. This far exceeds what annotations provide and includes safety caveats to prevent misuse.

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?

Though long, every section earns its place: classifiers, fan-out examples, response shapes, resolver contract, parent_event, news fields, safety, and resolution-rule risk. The use of headers and concrete examples makes it highly structured and information-dense, not verbose.

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

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

With no output schema, the description must explain return values, and it does comprehensively: result.market fields, result.analysis with model probability/edge warnings, result.evidence, parent_event, status codes, and cancellation rules. It also covers failure/edge cases, making it complete for a complex tool.

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

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

Schema coverage is 100%, but the description adds real value: it explains that 'market' accepts slug, URL, or question text; 'depth' quick vs thorough is detailed ('quick = 2-3 evidence sources, thorough = full fan-out'); and 'include_raw' describes size trade-offs and use cases. This goes beyond the schema's 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 opens with a specific verb+resource: 'Research a Polymarket bet by pulling the relevant Pipeworx data for it in one call.' It clearly distinguishes from sibling tools by focusing on data aggregation for bet analysis, with explicit 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 states when to use: 'Use for "should I bet on X", "what does the data say about Y", or "is there edge in Z".' It also gives depth parameter guidance. However, it does not explicitly name alternative tools or provide a 'when-not' directive, so it falls short of a 5.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false) already establish safety, but the description adds non-obvious behavior: it pulls specific metrics (10-K revenue/net income/cash/debt for companies; FAERS/approval/trial counts for drugs), sorts results by primary metric, and returns paired data with citation URIs. No contradiction with annotations.

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

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

The description is concise given the tool's complexity, front-loaded with trigger phrases and usage guidance. Every sentence adds value (trigger phrases, preference directive, data sources, sorting behavior, return shape, efficiency claim). 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?

The description covers both entity types, their data sources, fiscal year nuances, sorting behavior, and return value format (paired data + citation URIs). Given no output schema, this sufficiently explains what to expect. It addresses edge cases (off-calendar fiscal years) and performance (replaces 8–15 lookups), making it complete for an agent to select and 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 descriptions are thorough, giving full coverage (100%) of type and values. The description enriches these by specifying what each type retrieves (e.g., 'type="company" pulls LATEST 10-K revenue + net income + cash + long-term debt') and clarifies the values format (tickers/CIKs vs drug names). This goes beyond the schema, though the core parameter names are already well-described.

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

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

The description explicitly states the tool performs side-by-side comparisons of 2–5 companies or drugs in one parallel call, using specific trigger phrases like 'X vs Y' and 'which is bigger'. It clearly distinguishes itself from sequential single-pack lookups and mentions it replaces 8–15 sequential calls, setting it apart from sibling tools like entity_profile.

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

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

It provides explicit guidance: 'ALWAYS PREFER over sequential single-pack lookups when comparing entities.' It also clarifies when to use company vs drug types and notes off-calendar fiscal year handling. This gives clear context for selection and excludes 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 carry the safety profile (readOnlyHint, idempotentHint, openWorldHint, non-destructive), and the description adds substantial context beyond them: account/paid-tier requirements, a never-hallucinates guarantee via explicit gaps[], contradictions[] behavior per depth, semantic excerpting rather than head-truncation, resolvable citation_uri semantics, and concrete latency expectations (15-60s, ~90s for thorough). No contradiction with annotations.

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

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

Long (~220 words) but every sentence earns its place for a tool with this behavioral complexity: auth gate, alternative routing, scope, mechanism, output packet, gap honesty, depth variants, citation resolvability, and latency. It is front-loaded with the account requirement and alternative routing. Slight redundancy in the repeated 'one call' phrasing and single dense paragraph keep it from a 5.

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 must explain return values — and it does thoroughly: findings packet with verbatim evidence, confidence, source, fetched_at, stable pipeworx:// citation, gaps[], contradictions[], hop field, and citation_uri resolvability. Combined with high schema coverage and rich annotations, nothing an agent needs to select and invoke this tool 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 detailed enum descriptions for depth already present, establishing baseline 3. The description adds real value beyond the schema: the paid-plan requirement tied to 'thorough', the full multi-hop mechanism ('chases the best leads from the first pass — so multi-step questions resolve in one call'), and latency variance per depth tier. Not a huge margin over schema, but genuinely incremental.

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+resource: 'Grounded multi-source research across Pipeworx's 1517 STRUCTURED data sources ... in ONE call'. It actively differentiates from siblings by declaring 'this is NOT open-web search' and names ask_pipeworx as the alternative for single lookups. An agent can clearly tell this tool apart from the 34 siblings.

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

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

Provides explicit when/when-not guidance with named alternatives: 'If you are not signed in, use ask_pipeworx instead', 'For a single lookup use ask_pipeworx', and 'For BREAKING or colloquial CURRENT-NEWS ... prefer ask_pipeworx'. It also states exactly when deep_research is best: 'broad/multi-part questions over structured data', with concrete example queries.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable behavioral details: returns top-N most relevant tools with names, descriptions, full input schemas, curated examples, and results ready to call directly with no second schema lookup. This goes beyond the annotations, though it omits rate limits or edge cases.

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

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

The description is moderately sized but front-loaded with the core purpose. It efficiently covers what the tool does, when to use it, and what it returns. The domain list, while exhaustive, serves to illustrate scope and each sentence adds value.

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

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

Given the tool's complexity (6 params, all aliases) and no output schema, the description is reasonably complete: it explains the return format, usage scenarios, and provides concrete examples of queries via the schema. It doesn't explain relevance ranking, but that's not necessary for usability.

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

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

Schema description coverage is 100%, with each parameter and alias clearly documented in the input schema. The description does not add significant parameter-specific meaning beyond what the schema already provides; it only aligns with the query concept and mentions top-N which corresponds to the limit parameter. Baseline 3 is appropriate.

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

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

The description clearly states the tool finds tools by describing the data or task, with a specific verb and resource. It distinguishes itself from sibling domain-specific tools by positioning itself as a meta-search tool for discovering which tools exist, reinforced by 'Call this FIRST'.

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

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

Explicit usage guidance is provided: 'Use when you need to browse, search, look up, or discover what tools exist for...' and 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This clearly indicates when to use 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 cover readOnly, idempotent, and non-destructive hints, but the description goes far beyond by disclosing the fan-out behavior across multiple sources, the soft-fail for USPTO PatentsView (sunset May 2025), the sources_used/sources_failed pattern that distinguishes real 'no data' from bugs, and the behavior for private companies. It even notes that some sections (fda_products) may be empty for valid companies. This fully discloses operational quirks and failure modes, adding substantial value beyond the annotations.

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

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

The description is a dense block of text, but every clause carries signal. It leads with usage examples and the 'ALWAYS PREFER' directive, then enumerates sources and return fields. It would benefit from bullet points for readability, but given the breadth of information (multiple sources, edge cases, output fields), the density is warranted and it is not padded with fluff. The opening examples and override directive make it efficient for an agent to parse quickly.

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 must fully specify what the tool returns, and it does: cik, company_name, recent_filings (with URI format), fundamentals (LATEST 10-K metrics), patents, federal_contracts, fda_products, hiring, news, and LEI, plus sources_used/sources_failed. It also documents edge cases (private company, no FDA products, USPTO soft-fail) and the acceptable input formats. An agent has everything needed to call it correctly and interpret the response, even without an output schema.

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

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

Schema covers both parameters with 100% coverage, so the baseline is 3. The description adds crucial nuance: it clarifies that 'type' accepts 'company' or 'ticker' interchangeably and that value can be a ticker, CIK, or company name, while also explaining that names resolve via EDGAR company-name match. This extra clarity on the interchangeability and resolution behavior goes beyond the schema's enum text, justifying a 4.

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

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

The description opens with concrete user phrasings ("Tell me about X" / "research Acme") and then states the precise deliverable: "full cross-source profile of a US public company in ONE parallel call." It lists the exact data sources (SEC EDGAR, XBRL, USPTO, USAspending, FDA Purple Book, DOL LCA, GLEIF, news) and the returned sections (cik, recent_filings, fundamentals, patents, etc.). This is a specific verb+resource that clearly distinguishes it from siblings like compare_entities, deep_research, or resolve_entity, which are separately scoped.

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: "ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view." It provides concrete triggers (user requests a profile, briefing, company overview) and names the alternative pattern to avoid (chaining). It also handles edge cases: private companies return resolved:false with a notes line, and empty sections (e.g., no FDA products) are expected, not failures. This gives the agent clear 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?

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is known. The description adds context about clearing sensitive data and pairing with remember/recall, but does not go beyond annotations to describe irreversibility, error behavior, or 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 three short sentences, each serving a distinct purpose: stating the function, giving usage conditions, and naming related tools. It is front-loaded with the primary action and contains no filler.

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

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

The tool has a single parameter, a complete input schema, and annotations covering safety. The description covers purpose, when to use, and related tools. No output schema is provided, so no return value details are needed. It is fully sufficient for an agent to select and invoke the 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%: the only parameter 'key' has a description ('Memory key to delete'). The tool description itself does not add any additional semantic detail beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description opens with 'Delete a previously stored memory by key,' which clearly states the action (delete) and the target (previously stored memory by key). It distinguishes the tool from siblings by mentioning 'Pair with remember and recall,' placing it within the memory management family.

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

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

The description provides explicit use cases: 'when context is stale, the task is done, or you want to clear sensitive data.' It also references companion tools ('Pair with remember and recall'), giving context for alternatives, though it does not explicitly state when not to use the tool or name direct 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?

With strong annotations (read-only, idempotent, non-destructive), the description adds valuable process details: it fetches the page, extracts title/description/key links, and emits standard markdown. It does not mention limits like rate limits or error handling, but the annotations cover safety.

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

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

Two sentences, front-loaded with the core purpose, followed by process and use cases. Every sentence adds value with no redundant content.

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

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

The description explains the output format (single text blob, llms.txt markdown) despite lacking an output schema. It covers intended usage and behavior adequately for a relatively simple tool, but could mention internet access requirements or failure handling.

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?

Both parameters are fully documented in the schema (URL and max_links). The description adds context about 'any URL' and production-ready output, but does not provide new semantic details beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool generates a production-ready llms.txt file for any URL, specifying the action, resource, and outcome. It distinguishes itself from sibling tools by focusing on file generation rather than visibility checking or research.

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

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

The description provides explicit use cases (indexing a client's site, drafting for own project, auditing competitors) that signal when to use it. However, it does not mention alternatives or when not to use it, leaving a small gap.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds value by detailing exactly what the tool returns (fields, geometry type, record count, capabilities). It does not mention network/auth/error behavior, but the annotations lower the burden and the read-only nature is well covered.

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, information-dense sentence that front-loads the action ('Get') and resource ('ArcGIS Feature/Map Service layer's schema'). Every word contributes meaning; no filler 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 simple one-parameter, read-only tool, the description fully covers what it does and what it returns. The input schema covers the parameter, annotations cover safety, and the description explains the output components since there is no output schema. Complete and self-sufficient.

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

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

The input schema has 100% description coverage for the single 'url' parameter, including an example. The tool description adds no additional parameter-level semantics beyond restating that it is a URL. With high schema coverage, baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Get an ArcGIS Feature/Map Service layer's schema by url' and enumerates the specific output fields (fields, geometry type, total record count, capabilities). This is a specific verb+resource combination that distinguishes it from siblings like query_layer which would fetch data rather than 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 provides clear context: use this when you need schema information for a layer URL. It does not explicitly name alternatives or exclusions, but the mention of 'schema' makes it distinct from data-querying tools. No explicit when-not-to-use guidance is given, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is known. The description adds behavioral context by specifying it returns only the caller's own subscriptions and the exact fields included, without contradicting the annotations.

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

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

The description is two sentences, front-loaded with the core purpose, followed by return fields and usage guidance. Every sentence adds value with no redundancy.

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

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

The description covers purpose, scope, return fields, and usage recommendations. With a simple schema and robust annotations, it is sufficient for correct invocation, even though pagination or ordering details are not mentioned.

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

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

Schema coverage is 100% with the include_inactive parameter fully described in the input schema. The description does not add new parameter-specific meaning but aligns with the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool lists the caller's active subscriptions with a specific verb and resource. It distinguishes itself from sibling tools like subscribe and unsubscribe by focusing on listing, and enumerates the exact return fields.

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

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

The description explicitly recommends using the tool to review current monitoring before adding more, and to find an id to cancel. This gives clear context for when to use it, though it does not directly name alternative tools.

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

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

Beyond the minimal annotations, the description discloses important behaviors: filing without an account returns a claim_token that can be passed back to read resolution status, it is rate-limited to 5 per identifier per day, and it is free with no quota impact. These details give the agent accurate expectations for side effects and follow-up, and they align with the readOnlyHint=false annotation.

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

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

The description is lengthy but well-structured, with each sentence carrying distinct information: purpose, use cases, exclusions, content rules, claim_token flow, and rate limits. It avoids fluff and is front-loaded with the core purpose, though it could be tightened slightly by merging some clauses.

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

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

For a tool with zero required parameters and two distinct modes (submit feedback vs. check claim_token), the description covers submission criteria, exclusions, follow-up mechanics, and operational limits. Since there is no output schema, the description adequately explains the expected return (claim_token, later status), making it complete.

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

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

The schema already provides 100% coverage for all 4 parameters, but the description adds cross-parameter guidance: it explains how to use `type` for categorization, instructs to reference Pipeworx tools in `message`, and clarifies that `claim_token` is used alone 'with no other arguments' to retrieve a prior response. This supplements the schema without redundancy.

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 identifies the specific action (sending feedback) and resource (Pipeworx team), and is clearly distinct from sibling research and subscription 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 gives explicit when-to-use guidance ('Use when a tool returns wrong/stale data...') and exclusions ('ONLY for tools served by this Pipeworx connection — if the tool came from a different MCP server... file it with that server instead.'). It also instructs on content formatting, making it easy for an agent to choose this tool over alternatives.

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

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

Annotations already declare readOnly and idempotent hints, but the description adds substantial context: data source (CF analytics-engine), no PII, caching (5min-1h), and the self-aggregating nature. This goes beyond the annotation metadata and helps the agent understand response characteristics and limitations.

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: a lead sentence stating the purpose, a list of use cases, and a compact note on data provenance/caching. Every sentence adds information without repeating schema or annotations.

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

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

For a simple single-parameter read-only tool, the description covers output (top tools, packs, counts), usage context, caching behavior, privacy, and data source. This is complete enough for an agent to decide when to call the tool and what to expect in the response, even without an output schema.

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

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

The schema fully documents the window parameter with an enum and description (100% coverage). The description adds interpretive value by explaining that shorter windows surface hot trends while longer windows show steady-state demand, which is beyond the schema's literal definition.

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 what the tool does: it returns trending tools, packs, and call volume on Pipeworx. This distinguishes it from query/research tools like ask_pipeworx or discover_tools, making the purpose unambiguous.

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

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

The description lists three explicit use cases (hot data sources, canonical tool confirmation, alignment with agent needs) and explains window trade-offs. However, it does not explicitly mention when not to use the tool or name alternative tools, so it falls just short of a 5.

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

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

The description is highly transparent, disclosing internal filters (SEMANTIC ANCHOR, PARTITION FILTER), the fill check against live CLOB depth, and the response fields. It even warns 'realizable_edge_pp ≤ 0 ... do not trade it', which goes far beyond the annotations that only state read-only/idempotent.

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

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

The description is long but front-loaded and well-structured with labeled sections (SEMANTIC ANCHOR, PARTITION FILTER, FILL CHECK). Every section adds operational detail, though the all-caps headings and dense paragraphs could be slightly more scannable.

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

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

Even without an output schema, the description explicitly lists the response structure: opportunities[] with gap_pp, suggested_trade, reasoning, and the partition_check object in event mode. It covers edge cases, filters, fill-check logic, and references companion tools, making it contextually 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?

Both schema properties have descriptions, but the tool description adds concrete examples ('fed-decision-may-2026'), notes that full Polymarket URLs are accepted, and explains the behavioral differences between passing event and topic, plus the no-arg behavior. This significantly supplements the schema.

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

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

The description opens with a precise verb and resource: 'Find arbitrage opportunities on Polymarket' and specifies the method (monotonicity violations + partition-sum checks). It clearly distinguishes the two modes (event vs topic) and the no-arg trending_scan, setting it apart from sibling tools like polymarket_edges.

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

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

The description explicitly prescribes when to use each mode: 'Call with NO args for a trending_scan', 'event (recommended for a specific market)', and 'topic (for cross-event scanning)'. It also names an alternative: 'For custom sizing use polymarket_fill_risk.'

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

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

Beyond the annotations (readOnly, idempotent, openWorld), the description discloses extensive behavioral details: the response segmentation under by_segment, edge calculation net of slippage, Kelly fractions capped at 0.25, the 24h-move warning, partition overround design with placeholder-slug filters, the 'rare-by-design' nature of concentrated_longshot, and the 1h caching keyed on knobs. It even explains why partition arbs return kelly_fraction_half=0 at the parent level, giving callers essential internal knowledge.

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 highly detailed and systematically structured with all-caps section headers (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT, TRADEABLE-EDGE KNOBS, RESPONSE TOP-LEVEL), making it scannable. However, it is very long and includes some duplication of schema parameter descriptions. While every sentence adds useful information, the sheer length makes it less concise than ideal for an agent to parse quickly.

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 (9 optional parameters, no output schema), the description is remarkably complete. It thoroughly explains the response structure (by_segment, fed_candidates/fed_note, _diagnostics), the reasoning behind filters, and even the caching behavior. Callers would have a clear mental model of what to expect and why certain segments might be empty, making this a fully self-contained description.

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

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

The input schema already provides 100% parameter coverage with detailed descriptions, so the baseline is 3. The tool description adds meaningful context beyond the schema, such as the 'TRADEABLE-EDGE KNOBS' overview and the critical explanation for min_partition_leg_kelly (that partition arbs always return parent-level kelly=0, so this knob filters per-leg instead). This extra context justifies a 4.

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

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

The description opens with a specific verb+resource+outcome: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It further clarifies the intended use case ('Built for "what should I bet on today"'), clearly distinguishing it from sibling tools like polymarket_arbitrage or polymarket_edge_tracker by focusing on edge discovery from Pipeworx 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?

The description provides clear context for when to use the tool: for daily discovery of betting opportunities without paging hundreds of markets. It also gives detailed guidance on knobs (e.g., min_liquidity/max_spread_pp to drop unrealizable edges) and a caveat about Fed bets being unreliable. However, it does not explicitly name alternative tools or state when NOT to use this tool in favor of a sibling, so it stops short of a 5.

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

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

The description adds substantial behavioral detail beyond the annotations: history is bounded by a 60-day snapshot TTL, snapshots have gaps when polymarket_edges doesn't run, and decay is computed from daily closes rather than intraday. This discloses important limitations and data characteristics that are not visible from 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 well-structured with explicit 'Args' and 'RESPONSE' sections, front-loading the core purpose. Every sentence adds meaningful detail, and the formatting improves scannability despite the length.

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

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

Given the complexity of the tool and lack of an output schema, the description is remarkably complete. It details the full response structure (tracked, expired, snapshot_dates), explains edge cases (gaps, TTL limits), and clarifies calculation methods, leaving little ambiguity for the agent.

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

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

Schema coverage is 100% with parameter descriptions, but the tool description adds extra context: days has a default of 14 and max 30 (schema says clamp 2-30), and window is explained as the snapshot family with examples. This enhances understanding of how the parameters affect the query.

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

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

The description clearly states the tool's purpose: 'Edge persistence and decay telemetry built from daily polymarket_edges snapshots.' It answers specific questions ('how long has this edge existed and is it shrinking?') and contrasts fresh vs. old edges, distinguishing it from sibling tools like polymarket_edges which likely focuses on current edges.

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

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

The description provides strong usage context by explaining when this tool is valuable: to assess edge persistence and decay, noting that 'a fresh wide edge and a 3-week-old wide edge are different trades.' While it doesn't explicitly name alternatives or exclusions, the context makes it clear when to use it relative to other Polymarket tools.

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

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

Annotations already indicate readOnly, openWorld, idempotent, and non-destructive behavior. The description goes far beyond no-ops by detailing exact operational behavior: it 'walks the ladder,' returns specific fields (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd), and warns about the critical risk that 'partial basket fills convert an arb into an unhedged directional position.' This adds substantial context about execution mechanics and failure modes.

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 every sentence contributes necessary detail for two distinct modes. It is logically structured: starts with core purpose, then REQUIRES, then single-market details, then basket details, then usage guidance. While not as concise as a two-liner, the complexity of the tool justifies the length. A minor deduction for lack of formatting (single paragraph block) that makes it harder to scan.

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

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

There is no output schema, so the description carries the full burden of explaining return values. It enumerates all key output fields for both modes (top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict; theoretical_sum, realizable_sum, capture_ratio, profit_usd, per-leg fill detail, thin_legs[], max_clean_notional_usd, forced_directional_risk). It also covers edge cases like thin books and forced directional risk, making it complete for agent 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 description coverage is 100%, so baseline is 3, but the description adds significant meaning beyond the schema. For example, it clarifies that size_usd means 'max spend on buys, target proceeds on sells' in single-market mode, and 'settlement notional S (shares per leg)' in basket mode. It also explains side defaults per mode ('auto from partition sum') and the dual meaning of market vs event as mode selectors.

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 'Realizable-vs-theoretical edge check against live CLOB order-book depth,' which is a specific verb+resource+scope. It clearly distinguishes itself from siblings like polymarket_arbitrage and polymarket_edges by focusing on execution/fill risk rather than theoretical edge discovery. The usage directive 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500' further differentiates its role.

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

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

The description explicitly states when to use this tool ('USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500') and provides mode-specific guidance (SINGLE-MARKET vs BASKET). It also explains prerequisites ('REQUIRES one of market or event') and default behaviors, giving the agent clear actionable context for selecting it over 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?

Massive disclosure beyond the readOnly/idempotent annotations: explains that matching is keyword/overlap-based rather than a shared resolution source, describes all compatibility codes, notes that safety fields can be non-empty even with matched_pairs>0, clarifies that temporal_alignment null means uncomputable not aligned, states that spreads are gross and do not model Kalshi fees, and defines skipped counters. No annotation contradiction.

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

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

The description is long but exceptionally dense and front-loaded, with the core purpose stated first and then mode/response/safety details in clear labeled segments. Minor redundancy such as repeated 'in EITHER mode' is acceptable given the tool's complexity; no sentence fails to earn 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 present, the description fully documents the response shape, safety fields, compatibility code semantics, low-confidence/skipped pair behavior, temporal alignment object, fees note, and counters. An agent has everything needed to call the tool and correctly interpret the results.

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

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

Even with 100% schema coverage, the description adds critical semantic value: topic auto-fetches a pre-mapped event on each venue, explicit ticker/slug override the topic-mapped side, and both modes run the identical token-overlap matcher. This explains parameter interactions beyond the schema's individual 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?

States a specific verb and resource: computes the cross-venue spread between Kalshi and Polymarket for the same resolving question. It distinguishes itself from sibling arbitrage/edge tools by naming the two venues and the 'same question' pairing requirement.

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?

Clearly describes two modes (topic shortcuts vs explicit ticker/slug) and when each is appropriate, and warns that most pre-mapped topics return compatibility warnings today. However, it doesn't name sibling tools like polymarket_arbitrage or explicitly route an agent to them for single-venue or other use cases, so the guidance stops short of full alternative selection.

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

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

Annotations already declare readOnly=true, idempotent=true, and destructive=false, so the safety profile is covered. The description adds that it returns attribute rows and geometry, plus hints on how to sample, which is beyond the structured annotations.

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

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

Two sentences, no wasted words. The first sentence packs in the resource, the operation, and the key parameters; the second sentence provides a concrete usage tip. Ideal length and front-loading.

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

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

Given the tool has 6 parameters with full schema coverage and no output schema, the description covers the essential usage. It mentions return type (attribute rows and geometry) and a sampling strategy, leaving no major gaps for a query 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 parameters are fully documented in the schema. The description mentions SQL-like where, comma-separated out_fields, order_by, limit, and offset, but this only repeats schema details without adding new meaning beyond what is already present.

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 queries an ArcGIS Feature/Map Service layer by URL, which is a specific verb and resource. It also ties usage to search_datasets, distinguishing it from sibling tools like layer_info or search_within.

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

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

The description implies this tool is used after search_datasets ('by its url (from search_datasets)'), providing a clear usage context. It also gives a practical sampling tip ('where="1=1" + out_fields="*"'), but does not explicitly exclude alternatives.

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

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

Annotations already declare read-only and non-destructive behavior. The description adds important scoping details ('Scoped to your identifier') and lifecycle information ('Pair with remember to save, forget to delete'), which go beyond the structured annotations.

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

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

Three sentences, each serving a distinct purpose: function, use case, and operational context. No redundant or filler content. Information is front-loaded with the primary action in the first sentence.

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 a single optional parameter, the description fully covers purpose, usage, scoping, and relationships to sibling tools. Return behavior is implied (value vs. list of keys). No output schema is present, but the description handles the necessary context.

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

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

Schema coverage is 100% for the single key parameter. The description reinforces the parameter's meaning by explaining the behavior when omitted and providing concrete examples of key values (target ticker, address, research notes), adding richness 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 states a specific action: 'Retrieve a value previously saved via remember, or list all saved keys.' It clearly identifies the resource (memory store) and distinguishes from sibling tools by mentioning remember and forget explicitly.

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

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

The description provides clear context: 'Use to look up context the agent stored earlier' and mentions pairing with remember/forget. However, it does not explicitly state when not to use the tool or list specific alternative tools beyond the direct siblings.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds the significant behavioral detail that setting mark_read:true flags events as read, affecting subsequent calls. It also discloses the output fields (source, citation_uri, raw event payload) and that the same feed exists at an external URL. These go beyond the annotations and provide valuable behavioral transparency.

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

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

The description is compact and front-loaded with the core action. It covers retrieval, return fields, filters, mark_read behavior, polling suitability, and an alternative endpoint without any redundant or filler sentences. Every sentence earns its place.

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

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

Given no output schema and all-optional parameters, the description covers all essential aspects: what the tool returns, how to filter, the read-marker side effect, and the alternative HTTP access. Combined with annotations, this gives an agent a complete picture for correct invocation.

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

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

The input schema already describes all 5 parameters with 100% coverage. The description adds a concrete example for type ("sec_8k"), clarifies that type and since can be combined, and explains the effect of mark_read on future calls. This provides modest additional meaning beyond the schema.

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

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

The description opens with 'Pull fired events from your subscription feed', a specific verb and resource, and goes on to define the return content. It clearly distinguishes itself from sibling tools like list_subscriptions or recent_changes by focusing on fired alerts with optional filtering and mark_read semantics.

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

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

Provides clear context that this is for retrieving recent alerts and states 'Polls work fine', implying it is suitable for polling. It also points to an alternative REST endpoint for scripts/dashboards. However, it does not explicitly compare with sibling MCP tools, so it lacks exclusionary guidance but gives enough context for typical use.

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

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

Beyond the safe read-only annotations, the description discloses fan-out behavior to SEC EDGAR, GDELT→GNews fallback logic, USPTO sunset soft-fail, and the return structure (changes[] grouped by source + total_changes + citation URIs). This is rich behavioral context that annotations do not cover.

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 with useful information and front-loaded with user intent examples. While somewhat long, every sentence earns its place by conveying functional details or alternatives.

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, failure modes) and lack of output schema, the description fully explains return value shape, source-specific behavior, and the appropriate alternative tool, leaving no critical 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 baseline is 3. The description adds value by providing concrete examples for 'since' (ISO date vs '7d','30d','3m','1y') and clarifying that 'value' accepts ticker or zero-padded CIK, and 'type' is restricted to '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 in the last N days/weeks/months' with specific verbs and resources, and explicitly distinguishes itself from sibling tools like entity_profile. The trigger examples ('What's new with X') make the purpose immediately graspable.

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

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

It provides clear when-to-use guidance through natural language trigger phrases and explicitly names the alternative ('Use entity_profile instead when you want the static profile...'), making the usage boundary unambiguous.

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 idempotent, non-destructive write; description adds important behavioral context: key-value storage, identifier scoping, and 24-hour retention for anonymous sessions. This goes beyond the structured annotations to clarify real-world 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?

Four sentences, front-loaded with the core action, then usage guidance, storage details, and sibling relationships. 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 two-parameter write tool with no output schema, the description covers all critical aspects: purpose, usage timing, persistence behavior, and pairing with recall/forget. The schema covers parameter syntax, so the description is fully sufficient.

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 both parameters with examples (100% coverage), and the description adds the key-value storage context and identifier scoping. The examples in the description largely mirror the schema descriptions, so it adds modest 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 uses a specific verb ('Save data') and identifies the resource ('data the agent will need to reuse later'), and explicitly differentiates from siblings recall and forget. It is clear and unambiguous about the tool's function.

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

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

Provides explicit when-to-use guidance ('Use when you discover something worth carrying forward') with concrete examples, and contrasts with recall and forget. Also covers persistence differences for authenticated vs anonymous sessions.

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

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

Beyond the annotations (read-only, open-world, idempotent), the description discloses substantial behavior: it cascades through multiple lookup endpoints, degrades gracefully when GLEIF/OpenFIGI is unavailable, returns figi_candidates on ambiguous matches, and explicitly reports unresolved identifiers. This goes well beyond what annotations alone convey.

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

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

The description is long but front-loaded with the core purpose and usage rule. The extended parentheticals and per-type explanations are dense and mostly necessary given the tool's multi-source complexity, though some phrasing could be tightened without losing meaning.

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 two-parameter tool with no output schema, the description is remarkably complete: it covers accepted input forms per type, resolution behavior, ambiguity handling through figi_candidates, source labeling, unresolved-identifier reporting, and degradation behavior. An agent has enough context to select and invoke this tool correctly in edge cases.

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

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

Although the schema already documents both parameters, the description adds critical operational semantics: pass the entity name only, use the issuer exactly as printed for bonds, and avoid trailing security-class words because 'the FIGI lookup matches instrument names.' It also gives concrete examples for ticker, CIK, ISIN, and drug names, which materially helps correct invocation.

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 queries then states the precise function: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It clearly distinguishes this as a first-step identifier lookup tool rather than a profiling or comparison tool among the siblings.

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

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

The description gives an explicit trigger condition: 'Use FIRST whenever you have a name but need an ID.' It also clarifies which types and inputs are supported. However, it does not explicitly say when not to use this tool or directly name alternative sibling tools for other lookup scenarios.

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

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

Annotations already indicate a safe read-only, idempotent operation. The description adds valuable context by revealing it makes multiple probes via ai_visibility_check, ranks results, and returns score/confidence/signal density. 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?

Three concise sentences with no redundancy: core action, how it works, and return value. Front-loaded with 'Compare AI visibility across multiple entities side-by-side.'

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 states what is returned (ranked list with score, confidence, signal density). It also explains the underlying probe mechanism, making the tool's behavior understandable. The use case and entity semantics are covered.

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

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

Schema covers all 4 parameters with descriptions (100% coverage). The description adds little beyond saying the first entity is the subject and others are competitors, which is already in the schema. Baseline 3 is appropriate for full 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 uses a specific verb ('Compare') and resource ('AI visibility across multiple entities') and clearly distinguishes from siblings like ai_visibility_check by emphasizing side-by-side, ranked comparison. It also states the output (most/least recognized) making the purpose unambiguous.

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

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

It provides a clear use case ('competitive AI-marketing audits') with an example query. It implies the alternative (use ai_visibility_check for single entity) by stating it probes each entity with that tool, but doesn't explicitly name it as an alternative or state when not to use this tool.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive nature. The description adds substantial behavioral context: fan-out across two services, potential 5-30s delay for first bundlephobia measurement, graceful partial failure via sources_failed, and details of the return payload. No contradiction with annotations.

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

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

The description is longer than typical but well-structured: purpose first, then usage, then behavior/caveats. While slightly verbose, every sentence provides useful information and there is no filler. It earns its length for a composite tool with multiple external dependencies.

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

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

With no output schema, the description fully enumerates the return structure (summary block fields, per-advisory details, links, alternative versions) and explains error/partial-failure behavior. For a complex tool with two external data sources and potential timeouts, this is complete and self-contained.

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% (both package and version are described). The description adds no new parameter details beyond the schema; the schema already covers scoped packages and default version. Baseline 3 is appropriate since 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 clearly states it is a composite 'should I add this npm package to my project' check, specifying the exact data sources (deps.dev and bundlephobia). It names specific outputs and distinguishes itself from sibling tools by being the dedicated npm dependency assessment 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?

Explicitly says 'Use whenever an agent asks...' and provides concrete example queries. It also gives an exclusion: NPM only in v1, and directs other ecosystems to deps.dev:version directly. This fully guides when to use and when not to.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds useful behavioral context by specifying exactly what is returned (name, summary, record_count, owner/org, Feature Service url) and how the result should be consumed. No contradictions with annotations.

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

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

The description is two sentences, front-loads the core purpose, and includes a valuable downstream usage hint. Every phrase carries information; no filler or repetition of schema details.

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

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

Even without an output schema, the description explicitly lists the return fields and explains how the result is meant to be used. Given the simple keyword-search nature and rich annotations, the description provides enough complete context for an agent to select and invoke the 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%: query, limit, and org_id all have meaningful descriptions. The tool description itself adds no parameter-specific detail beyond 'by keyword', but the schema covers the parameters adequately, so the baseline of 3 is appropriate.

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

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

The description states a specific action ('Search East Baton Rouge GIS open geospatial datasets') and a clear resource scope ('parcels, addresses, public works & planning'). It distinguishes itself from siblings by defining its output as dataset metadata plus a Feature Service url for downstream use with query_layer/layer_info.

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

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

The description provides clear context: use this to discover datasets by keyword, then take the returned `url` to query_layer or layer_info. It does not explicitly state when not to use it compared to search_within or other siblings, but the downstream chaining makes the intended flow clear.

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

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

Annotations already mark readOnly, idempotent, openWorld, and non-destructive, but the description adds substantial behavioral detail: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap with truncation flagging, and return fields (character offsets and similarity scores). This goes beyond what annotations alone provide, with 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 yet focused. Every sentence carries purpose: it states the action, gives use cases, explains the algorithm and limits, and situates the tool among siblings. It is front-loaded with the core purpose and does not waste 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 tool with no output schema and moderate complexity, the description covers all critical aspects: what it does, when to use it, how it works under the hood, input constraints, output characteristics (passages with offsets and scores), and relationship to other tools. The agent receives enough context to invoke 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 contextual meaning by specifying that 'text' is content already pulled (e.g., SEC 10-K body) and that 'query' is a natural-language question, with examples. It also clarifies the 'limit' parameter's purpose via 'top-N passages.' While the schema already documents constraints, the description enriches the practical understanding of each parameter.

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 specific verb and resource: 'Semantic search INSIDE a fetched record.' It distinguishes itself from siblings like search_datasets by focusing on already-fetched text and from ask_pipeworx_grounded by acting as a companion rather than a replacement. The use case (search within a document too large for the prompt) is explicit.

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

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

It provides explicit when-to-use guidance: 'Use when the record is too big to cram into the prompt.' It also contrasts with ask_pipeworx_grounded by explaining how they pair together, and it mentions the value of character offsets for verification. Alternatives and complementary tools are both identified.

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

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

Annotations already indicate this is not read-only, is idempotent, and has open-world side effects. The description adds valuable context: OAuth requirement, subscription ID returned, SMS verification and daily cap, and the always-on feed behavior. No contradictions with annotations.

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

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

The description is dense but well-structured, front-loading the core purpose and then laying out types and delivery. Every sentence carries specific information, though it is slightly long. Schema details for webhook are also included, making it compact but efficient.

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

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

Given the complexity (3 parameters, nested objects, 5 types, multiple delivery options) and no output schema, the description covers the main behavior, return (subscription ID), and prerequisites. It omits some return details beyond the ID and error handling, but the main usage is fully fleshed out.

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

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

The input schema has 100% coverage, and the description enriches it with concrete examples for each type (sec_8k items, polymarket topic, fred series) and clarifies delivery options. This goes beyond the schema's enum and object 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 states a specific verb and resource: "Create a proactive monitoring subscription to a live-data event stream." It clearly lists supported subscription types and delivery channels, which differentiates it from sibling tools like list_subscriptions, unsubscribe, and recent_alerts.

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

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

Provides clear context on when to use: requires a Pipeworx OAuth account, anonymous/BYO cannot persist, and explains how to consume feeds (recent_alerts or direct GET). It does not explicitly exclude alternative one-time query tools, but the proactive monitoring scenario is made 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?

Beyond annotations (read-only, idempotent), the description adds valuable behavior details: it returns category-bucketed examples from the live catalog, includes tool+argument shapes, behaves differently with no args vs a topic, and teaches meta-tool invocation. This enriches the agent's understanding of what the call does and 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 front-loaded with example phrasings and logically structured, but it is verbose (over 150 words) for a tool with one optional parameter. Some phrasings (e.g., 'give me ideas', 'show me examples') are repetitive; the content could be trimmed without losing essential guidance.

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

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

The description fully explains what is returned (category list, tool+argument shape, live catalog), how to invoke with/without parameters, and when to use it first. It even orients the agent to meta-tools, making it a complete onboarding resource despite the absence of an output schema.

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

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

Input schema covers the only parameter (topic) with 100% detail, including allowed values and behavior when omitted. The description adds only a few redundant examples ('finance', 'pharma', 'betting') that do not exceed schema meaning, so baseline 3 applies.

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

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

The description precisely states the tool's role as an onboarding entry point that returns category-bucketed example questions with exact tool calls, distinguishing it from siblings like ask_pipeworx, discover_tools, and deep_research by focusing on 'what is worth asking' rather than answering or discovering broader capabilities.

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

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

It explicitly instructs 'Use this FIRST when you do not yet know what Pipeworx can do for you' and mentions related meta-tools to learn. However, it does not explicitly state when NOT to use it or contrast with discover_tools, which could serve a similar onboarding role, so exclusion criteria are missing.

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

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

Beyond annotations (which indicate idempotent and non-destructive behavior), the description explicitly states that the row is deactivated and not deleted, preserving historical events via recent_alerts. This adds meaningful behavioral context about the operation's side effects and data retention.

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

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

Three short sentences each add distinct information: the action, ownership restriction, and the deactivation side effect. It is front-loaded and free of redundancy, making it highly readable and efficient.

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

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

Given the single parameter, no output schema, and sibling tools, the description covers the essential context: what happens to the subscription, who can perform it, and where historical data remains available. It is sufficiently complete for a simple mutation tool.

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

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

The schema fully documents the single parameter (id) with the same 'returned by subscribe' phrasing. The description adds nothing new about the parameter semantics beyond restating that it is a subscription id, so the baseline score of 3 applies.

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

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

The description starts with the specific verb 'Cancel' and resource 'subscription', clearly stating the action. It distinguishes from sibling tools like subscribe, list_subscriptions, and recent_alerts by focusing on the cancellation action and its side effects.

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

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

The description provides clear context about ownership enforcement and the deactivation behavior, which helps decide when to use this tool. It doesn't explicitly name alternatives but the context is sufficient for a straightforward unsubscribe action.

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

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

Beyond the read-only/idempotent annotations, the description discloses critical behavioral details: the meaning of could_not_verify (check did not happen, not evidence) vs. unsupported, and that it returns verdicts with evidence and citations. It even warns callers not to treat could_not_verify as supporting/refuting. This goes well beyond what annotations provide.

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

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

Although the description is lengthy, every sentence contributes value: trigger phrases, routing logic, output structure, and error-handling warnings. It is well-structured with front-loaded purpose, and no filler 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?

With no output schema, the description fully explains the return verdicts, the evidence/citation format, and error semantics (could_not_verify carries verification_error). It also covers the fast path vs. grounded pipeline, making it sufficient for an agent to select the tool and interpret results correctly.

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

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

The schema already provides detailed descriptions for both parameters (claim example and tolerance_pct semantics). The tool description does not add additional parameter meaning beyond what is in the schema, so the baseline of 3 applies due to high 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 defines the tool as natural-language claim verification against authoritative sources, with explicit trigger phrases like "Is it true that…" and "fact check". It specifies verdict types and the scope (company-financial vs. other claims), making it distinct from generic search 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 gives explicit usage context: "Use whenever the agent needs to check whether something a user said is factually correct." It also explains internal routing for financial vs. other claims. However, it does not explicitly name alternative sibling tools or state when not to use it, so it stops short of a full 5.

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