Fdic

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is clear. The description adds behavioral context about cost (BYO key for Anthropic) and return structure (per-model fields + combined view), which goes beyond annotations.

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

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

The description is concise (4 sentences) and front-loaded with the core action and result. Every sentence adds value without redundancy.

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

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

Despite no output schema, the description explains the return structure and all parameters are covered. The tool is fully understandable for selection and invocation.

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

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

Schema description coverage is 100%, but the description adds meaning beyond the schema by explaining default model, when apiKey is needed, and the purpose of context. This helps agents use parameters correctly.

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 ('Probe') and resource ('LLMs') and clearly defines the output (visibility score 0-100). It distinguishes from siblings by focusing on multi-model AI visibility scoring, which is unique among tools like 'scan_competitor_ai_presence' or 'ask_pipeworx'.

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

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

The description covers when to use (AI-marketing audits, brand checks) and explains optional parameters (apiKey for Anthropic). However, it does not explicitly state when not to use this tool or compare it to alternatives, leaving some ambiguity.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), so the bar is lower. The description adds useful behavioral context: internal routing to many tools, automatic argument filling, return format with stable pipeworx:// citation URIs, and that it works on every tier. It does not add details on rate limits or failure modes, but annotations cover the key safety profile. 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 average but well-structured, with clear signals like 'PREFER OVER WEB SEARCH', 'START HERE', and 'Step up only when needed'. It front-loads the key purpose and provides organized sections for when to use and when not to. While it contains some redundancy (e.g., repeating the query-phrase list), the structure helps navigate the length. It earns its place for a complex, high-utility tool.

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

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

For a tool with 6 alias parameters and no output schema, the description is thorough: it explains the scope (many domains), the output format (structured answer with citations), the relationship to sibling tools, and the default entry point status. It gives concrete examples and covers edge cases like breaking news. It is complete enough for an agent to decide when to use 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%, with the 'question' parameter well-documented and aliases listed. The description adds examples of valid queries and clarifies the expected input (natural language factual questions) but does not add new parameter-specific syntax or constraints beyond the schema. The examples in the schema already cover usage, so the description adds marginal parameter-level value.

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

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

The description explicitly states what the tool does: routes questions to the right tool among 5,529 across 1,455 sources, fills arguments, and returns structured answers with citations. It clearly distinguishes from siblings by naming ask_pipeworx_grounded and deep_research, and specifies that it is the default entry point for factual questions.

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: 'PREFER OVER WEB SEARCH', 'Use whenever the user asks...', 'START HERE for most questions'. It also lists alternatives and when to step up: 'for hallucination-resistant... use ask_pipeworx_grounded; for broad/multi-part... use deep_research', and clarifies that breaking news is already handled. This is comprehensive, including exclusions and 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 provide readOnly, openWorld, idempotent, and non-destructive hints. The description adds crucial behavioral context beyond annotations: it's a beta that may route differently when candidates are under test, currently matches ask_pipeworx exactly because the last candidate was retired, and is a full working router rather than a fallback. This is substantial additional transparency about its dynamic behavior.

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

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

The description is front-loaded with the beta identity and every sentence contributes to clarifying purpose, usage, and current state. There is minor redundancy (e.g., 'identical' and 'matches ask_pipeworx exactly') but it's not wasteful and aids clarity. Overall compact given the complexity.

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

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

For a complex router tool with no output schema, the description explains its relationship to ask_pipeworx, current behavior, and experimental status sufficiently. It mentions the same response shape, relying on ask_pipeworx's documentation for exact return details. Annotations cover safety and side-effect profile, making this complete enough for selection and invocation.

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

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

Schema coverage is 100% with clear descriptions for the question parameter and all aliases. The description only says 'same arguments' without adding any detail, so it provides no additional value beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly identifies the tool as a beta version of ask_pipeworx, a universal router with 5,529 tools, and emphasizes its experimental nature. It distinguishes itself from sibling ask_pipeworx by framing itself as the 'experimental edge' with candidate routing improvements.

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

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

Explicitly instructs to 'Use it exactly like ask_pipeworx when you want the newest routing', and explains that results are compared against the stable router to decide merges. This gives a clear when-to-use and implies the alternative (stable ask_pipeworx) for non-experimental needs. The statement 'Falls back to nothing — this IS a full working router' further clarifies it's not a stub.

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

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

Beyond the annotations (readOnly, openWorld, idempotent, non-destructive), the description adds key behavioral details: it EXTRACTS answers using ONLY tool results, returns structured refusal reasons for five failure modes, and costs one extra LLM call. This significantly enhances transparency 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 dense and front-loaded with the core purpose, followed by return format, refusal reasons, usage guidance, and cost note. Every sentence earns its place, but it is longer than necessary and packs many details into a single block, so it loses one point for structure.

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

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

There is no output schema, so the description must explain return values—and it does thoroughly with the success object and explicit refusal reasons. Combined with usage guidance, cost tradeoff, and the fact that all parameters are aliases for 'question', an agent has complete information to select and invoke correctly.

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

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

The input schema has 100% coverage, documenting 'question' and all five aliases as natural language queries. The description does not add parameter-specific meaning beyond saying the routing 'fills arguments' from the question, so the schema carries the load. 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 is a 'hallucination-resistant answer mode for high-stakes reads' with a specific verb+resource: it EXTRACTS answers using only tool results. It distinguishes from sibling ask_pipeworx by noting the extra LLM call and verbatim evidence return, so an agent knows exactly what this variant does.

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

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

Explicitly states when to use: 'whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts', including examples. Also gives an exclusion: 'prefer ask_pipeworx for casual lookups', naming the alternative and the cost tradeoff.

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 idempotent. The description adds extensive behavioral details: resolver contract, parent_event extractor, news fallback handling, safety short-circuits, closed market behavior, wide-spread illiquidity, and resolution-rule risk. No contradictions.

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

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

The description is overly verbose, spanning many details and examples. While well-structured with sections, it would benefit from brevity to aid quick agent parsing.

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

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

Despite no output schema, the description thoroughly explains response shapes, evidence structure, and all edge cases (low-confidence, closed markets, wide spreads, cancellation rules). It compensates fully for missing schema.

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

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

Schema coverage is 100% with descriptions. The description adds value by explaining parameter variants (slug, URL, text), depth options with defaults, and include_raw behavior. Examples further clarify usage.

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

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

The description clearly states the tool researches a Polymarket bet by pulling Pipeworx data, with specific input types (slug, URL, question text). It distinguishes itself from sibling tools like polymarket_arbitrage by focusing on evidence gathering and edge analysis.

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

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

Explicit use cases are given ('should I bet on X', 'what does the data say', 'is there edge in Z'). It also covers edge cases like low-confidence matches and closed markets, but lacks explicit when-not-to-use guidance compared to alternatives like ask_pipeworx.

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 rich behavioral context: data sources (SEC EDGAR/XBRL for companies, FAERS for drugs), handling of off-calendar fiscal years, result sorting, and return format (paired data + 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 well-structured and front-loaded with trigger phrases. It is moderately lengthy but each sentence adds value. A slightly more structured format (e.g., bullet points) could improve readability, but it remains concise for the information conveyed.

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

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

Given the tool's complexity (two entity types, multiple data sources, no output schema), the description thoroughly covers behavioral nuances (fiscal year handling, sorting), return format (paired data + URIs), and efficiency claims. It leaves no obvious gaps for correct invocation.

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

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

Schema coverage is 100% and the description adds significant meaning beyond the schema: it explains what each type retrieves, gives examples of values (tickers/CIKs for company, names for drug), clarifies maxItems/minItems, and notes that results are sorted by primary metric. This exceeds baseline expectations.

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

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

The description uses specific trigger phrases like 'Compare X and Y', 'X vs Y', and 'rank these companies', clearly stating it performs side-by-side comparisons of 2-5 companies or drugs in a single parallel call. It effectively distinguishes itself from sibling tools by recommending preference over sequential lookups.

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

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

The description explicitly states when to use the tool (e.g., when user says 'compare', 'vs', 'versus', 'rank') and gives a strong preference directive: 'ALWAYS PREFER over sequential single-pack lookups'. It also clarifies that type='company' and type='drug' serve different use cases.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description reveals key behaviors: account tiers, parallel routing, gap-recovery, contradictions scan, citation URI resolvability, semantic excerpting, and expected latency. It also discloses that current-news topics will return empty gaps and that citations are only included when fetchable, adding substantial context 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?

The description is verbose but information-dense; every sentence earns its place. It is front-loaded with the critical account requirement and maintains a logical flow from purpose to alternatives to operational details. It could be improved with bullet points or shorter sentences, but it is not padded.

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

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

With no output schema, the description compensates by thoroughly describing the return packet structure: verbatim evidence, confidence, source, fetched_at, citation URI, gaps[], contradictions[], and hop fields. It also clarifies how large records are handled and sets time expectations. For a tool of this complexity, this is as complete as one could 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?

The input schema covers 100% of parameters, so the baseline is 3. The description adds depth beyond the schema by explaining the practical effects of each depth level (gap recovery, contradictions, follow-up hops, time) and confirming that natural-language multi-part questions are accepted. It doesn't add format details for 'question' beyond the schema, but the extra contextual info for 'depth' 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 clearly identifies deep_research as grounded multi-source research across Pipeworx's 1,455 structured data sources, explicitly distinguishing it from open-web search and sibling ask_pipeworx. It uses specific verbs like 'Decomposes', 'routes', and 'returns', and provides concrete examples of use cases, making the purpose unmistakable.

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

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

The description explicitly states when to use deep_research ('Best for broad/multi-part questions over structured data') and when not to ('For a single lookup use ask_pipeworx', 'For BREAKING or colloquial CURRENT-NEWS ... prefer ask_pipeworx'). It also names the alternative tool and explains the account requirement, offering clear when-to-use vs 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 declare readOnlyHint, idempotentHint, destructiveHint. Description adds useful detail: returns top-N, includes curated examples, and results are ready to call directly. 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?

Description is a single paragraph that efficiently communicates purpose, usage context, and return format. Could be slightly more structured but is clear and concise.

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

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

No output schema, but description explains return value: 'top-N most relevant tools with names, descriptions, and full input schemas.' All 6 parameters are covered by schema and description. No gaps.

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

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

Schema coverage is 100%, so baseline is 3. Description adds value by explaining the query parameter accepts natural language and lists aliases (task, q, description, search) and mentions limit default/max.

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

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

The description clearly states the tool's purpose: 'Find tools by describing the data or task.' It lists many domains and explains that results include full schemas ready to call, distinguishing it from siblings like search_within or resolve_entity.

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

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

Explicitly advises 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' This gives clear when-to-use and context relative to alternatives.

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

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

Annotations (readOnlyHint, etc.) are complemented by description disclosing parallel execution, fan-out across sources, return structure specifics, and patents API sunset. 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?

Description is dense but efficient, front-loaded with example queries. Every sentence adds unique value, though it is somewhat long. No wasted words.

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

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

Considering no output schema, the description thoroughly details return components (CIK, filings with URIs, fundamentals sorted, patents soft-fail, news fallback, LEI). Also covers limitations and source dependencies.

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 high. Description adds value by reinforcing that only 'company' type is supported, explaining value formats (ticker or zero-padded CIK), and noting that names are not supported and resolve_entity should be used first.

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

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

The description clearly states the tool's purpose: 'full cross-source profile of a US public company in ONE parallel call'. It lists example queries and distinguishes from sibling tools like resolve_entity for name resolution. The verb 'profile' is specific and the resource is well-defined.

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 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups' for holistic views. Provides when-not-to-use: 'names not supported (use resolve_entity first)'. Also mentions patents soft-fail condition.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds that it returns specific fields but does not disclose additional behavioral traits beyond what annotations provide, so it meets the baseline without adding extra value.

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

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

Description is a single 16-word sentence that is front-loaded with the action verb and efficiently conveys the tool's purpose and output. No unnecessary words.

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

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

Given that annotations, full schema coverage, and an output schema exist, the description is sufficiently complete. It covers the core functionality and return fields, though it could mention the default limit or pagination behavior.

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

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

Schema coverage is 100% and already documents all three parameters clearly, including defaults and date formats. The description mentions 'date range' which aligns with start_date and end_date but adds no semantic meaning beyond the schema.

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

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

The description clearly states it searches FDIC bank failures by date range and lists specific fields returned. It effectively distinguishes itself from sibling FDIC tools like fdic_search_institutions or fdic_get_institution.

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 (searching FDIC bank failures by date range) but does not explicitly mention when not to use it or alternatives. However, the purpose is straightforward given the sibling tools.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds no extra behavioral context beyond listing return fields, which is partially redundant with the output schema. No contradiction with annotations.

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

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

The description is a single concise sentence, front-loaded with the core action. Every word serves a purpose, with no unnecessary detail.

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

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

Given the tool's simplicity and the presence of an output schema, the description covers the essential information. However, it could mention the default value for 'limit' (8) for added completeness.

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

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

Schema description coverage is 100% for both parameters (cert and limit), so the schema alone adequately documents them. The description mentions cert but adds minimal extra semantic meaning beyond the schema.

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

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

The description clearly states the tool's function: 'Get quarterly financial metrics for a bank by CERT ID.' It specifies a specific verb and resource, lists key return metrics, and distinguishes itself from sibling tools like fdic_failures and fdic_search_institutions.

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 no guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or comparisons to other FDIC tools, leaving the agent to infer applicability.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, so the safety profile is clear. The description adds that it returns a detailed profile with specific fields, but does not disclose any additional behaviors (e.g., rate limits, authentication needs). It does not contradict the annotations.

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

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

The description is a single concise sentence (19 words) that is front-loaded with the core action and resource, followed by a parenthetical example and return content. Every word adds value; there is no redundancy or fluff.

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

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

Given the tool's simplicity (one required parameter, output schema present, and annotations covering safety), the description provides sufficient context: it states what the tool does, what it returns, and includes an example. No additional information is necessary for effective use.

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

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

The input schema covers the sole parameter 'cert' with 100% description coverage, including an example. The tool description provides a similar example but adds no new meaning beyond what the schema already provides. Thus, the description does not enhance parameter understanding beyond baseline.

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

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

The description uses a specific verb ('Get') and resource ('detailed profile for an FDIC-insured bank') with concrete examples and return fields. It clearly distinguishes from sibling tools like fdic_search_institutions (which is for searching) and fdic_financials (financial data), as it focuses on a full profile by certificate number.

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

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

The description implies use when a specific bank's cert number is known, but it does not explicitly state when to use this tool versus siblings (e.g., fdic_search_institutions for search, fdic_failures for failed banks). No exclusions or prerequisites are mentioned, leaving room for ambiguity.

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, idempotent, openWorld, and non-destructive behavior. The description adds value by listing specific return fields, enhancing behavioral understanding. No contradiction with annotations.

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

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

The description is a single, well-structured sentence that front-loads the purpose and then lists return fields, all without unnecessary words. 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 a simple search tool with two parameters and an output schema present, the description covers the essential behavior. It could mention pagination or default limit, but the schema already defines limit. Overall adequate.

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

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

Schema coverage is 100%, so parameters are fully described. The description mentions searching 'by name', which aligns with the 'search' parameter, but adds no additional nuance beyond the schema. The 'limit' parameter is not discussed. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool searches FDIC-insured banks by name and lists the return fields, effectively distinguishing it from siblings like fdic_failures or fdic_get_institution which have different purposes.

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 when to use (searching banks by name) and is clear about the return fields, but does not explicitly state when not to use or compare with alternatives. Sibling tools like fdic_get_institution provide additional context for differentiation.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false. The description adds useful behavioral context: the default date behavior (most recent published year) and the default national scope. There's no contradiction with annotations, and the description enhances understanding of the tool's non-destructive, read-only behavior.

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

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

The description is three sentences, front-loads the core purpose, and every sentence earns its place. It avoids redundant phrasing and is well-structured for quick parsing.

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 an output schema present, the description doesn't need to detail return values. It covers the essential context: what aggregates, how parameters affect output, and the charter class split. This is complete for a relatively simple, well-annotated 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%, so the baseline is 3. The description adds semantic value beyond the schema by explaining how to use the optional parameters: omitting date returns latest data, passing year vs full date, and state defaults to national aggregate. This helps the agent understand the intended usage patterns.

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

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

The description starts with a specific verb and resource: 'Get aggregate totals for FDIC-insured banks.' It clearly differentiates from sibling tools like fdic_failures (failures), fdic_get_institution (individual institutions), and fdic_search_institutions (search), by focusing on aggregate totals. It also lists the exact metrics returned, leaving no ambiguity about scope.

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 clear usage instructions: omit date for most recent year, pass a specific year/report date, default to national aggregate, pass state for a state-level total. This implies when to use it. It doesn't explicitly name alternatives or exclusion scenarios, but the context is sufficiently clear for an agent to choose this tool over 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 indicate destructiveHint=true, readOnlyHint=false, and idempotentHint=true. The description adds the notion of 'previously stored' implying the key must exist, but does not clarify behavior for non-existent keys or confirm idempotency. It provides modest additional context about clearing sensitive data.

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

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

The description is extremely concise: two sentences with no wasted words. The first sentence front-loads the primary action, and the second provides usage guidance. Every sentence earns its place.

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

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

Given the tool's simplicity (single parameter, no output schema), the description covers purpose, usage guidelines, and sibling relationships. It lacks explanation of behavior for missing keys, but overall is sufficiently complete for a straightforward delete operation.

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 'key' parameter well-described as 'Memory key to delete'. The description only says 'by key', adding no new meaning beyond the schema. The example in the schema itself provides context, but the description does not enhance it.

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

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

The description clearly states 'Delete a previously stored memory by key', using a specific verb and resource. It distinguishes itself from sibling tools like 'remember' and 'recall' by explicitly pairing with them, making its purpose unambiguous.

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

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

The description provides explicit when-to-use scenarios: stale context, task completion, or clearing sensitive data. It mentions 'remember and recall' as related tools, offering implicit guidance on alternatives. However, it does not specify 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?

Discloses key behaviors: 'Fetches the page, extracts title/description/key links, and emits the standard llms.txt markdown format.' Annotations already indicate safe and idempotent, and description adds valuable context about what the tool actually does beyond annotations.

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

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

Two sentences plus a bullet list of use cases. Front-loaded with purpose, then usage scenarios. No wasted words; 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?

With 2 parameters, 100% schema coverage, and clear description of output format ('single text blob ready to drop at site-root/llms.txt'), the description is complete. No output schema needed as return value is sufficiently explained.

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

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

Schema coverage is 100%, so baseline is 3. Description does not add meaning beyond schema descriptions for parameters; it only mentions URL and max_links in passing within use cases. No extra semantic detail.

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

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

Description states specific verb ('Generate'), resource ('llms.txt file for any URL'), and output format ('standard llms.txt markdown format'). Clearly distinguishes from siblings like ai_visibility_check or deep_research which have different purposes.

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

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

Provides explicit use cases: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor.' Does not explicitly exclude scenarios, but context is clear. Siblings list shows no overlapping 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 readOnly, non-destructive, idempotent. Description adds that it returns specific fields and defaults to active subscriptions. No contradictions.

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

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

Two sentences: first states purpose and returns, second gives usage guidance. No wasted words, information front-loaded.

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

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

Simple tool with one boolean param. Description, combined with annotations, fully covers purpose, usage, and behavior. Output is clearly implied by listed fields.

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

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

Schema coverage is 100% for the single parameter. Description adds no extra parameter info beyond the schema, meeting baseline but not exceeding.

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 'List the caller's active subscriptions' with clear verb and resource. Lists return fields, distinguishing from subscribe/unsubscribe siblings.

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

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

Explicitly says when to use: review monitoring before adding more, or find an id to cancel. No exclusions but context is clear.

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

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

Beyond the annotation booleans, the description discloses valuable behavioral details: rate limiting to 5 per identifier per day, free usage that doesn't count against quota, the claim_token return-and-redeem flow, and the privacy guidance not to paste end-user prompts. These add substantial context beyond the minimal annotation hints.

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

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

Though longer than average, every sentence earns its place: purpose, categories, exclusions, claim_token mechanics, privacy guidance, roadmap impact, and rate limits. It is front-loaded with the core purpose and structured logically, with 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?

The description covers the full decision space: when to use, when not to use, how to describe the issue, what the claim_token does, rate limits, and quota impact. Even without an output schema, the agent is well-equipped to use the tool correctly and interpret the return flow.

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 giving a concrete claim_token usage example, explaining feedback should be described in terms of Pipeworx tools/packs, and reinforcing the message length expectation. Much of this overlaps with schema descriptions, so it doesn't reach a perfect 5.

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

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

The description opens with a specific action: 'Tell the Pipeworx team something is broken, missing, or needs to exist.' It clearly distinguishes this feedback tool from sibling tools by focusing on reporting bugs, feature gaps, data gaps, and praise related specifically to Pipeworx 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 for bugs, feature/data gaps, or praise. It also provides a clear exclusion: only report issues for tools served by this Pipeworx connection, not for tools from other MCP servers, and tells the user to file those elsewhere.

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

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

Beyond annotations (readOnlyHint, idempotentHint), the description adds caching details (5min-1h), data source (CF analytics), privacy (no PII), and output format (pack, tool, count). 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?

Well-structured: succinct summary, bulleted use cases, then technical details. Every sentence serves a purpose without redundancy.

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

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

For a simple tool with one optional parameter and no output schema, the description covers core behavior, caching, and use cases. Minor gap: no explicit return structure beyond 'top tools, top packs, total call volume'.

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

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

Schema coverage is 100%, and the description adds value by explaining the implications of different windows ('hot right now' vs 'steady-state demand'), which goes beyond the schema's enum description.

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

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

The description clearly states the tool returns top tools, top packs, and total call volume over a recent window, distinguishing it from siblings like discover_tools and ask_pipeworx by focusing on aggregated agent usage.

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

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

Three specific use cases are listed (discovering hot data sources, confirming popular tools, aligning use cases), providing clear context. It does not explicitly state when not to use it but differentiates from alternatives implicitly.

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

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

The description discloses extensive behavioral details beyond the annotations, including how the tool works internally (monotonicity violations, partition checks, Jaccard similarity, fill check), response structure (opportunities array, partition_check object), and edge cases (placeholder filtering, realizable edge ≤0). Since annotations are present, the description adds significant context without contradiction.

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

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

The description is well-structured and front-loaded with the core purpose, but it is quite lengthy with many technical details. Every sentence adds value, but some details could be summarized more tightly for conciseness. Still, the structure is logical and clear.

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

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

Given the tool's complexity (no output schema, 2 optional params, complex behavior), the description is remarkably complete. It covers all three usage modes, response fields, edge cases (placeholders, similarity filter, fill check), and even references a sibling tool for custom sizing. An AI agent would have sufficient information to use the tool correctly.

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

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

The input schema covers both parameters with descriptions, but the description adds deep semantic meaning: it explains the effect of each parameter (no args, event, topic) with concrete examples like 'fed-decision-may-2026' and the behavioral differences between modes. It also details cross-event scanning logic and fill check behavior, providing substantial value beyond the schema.

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

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

The description clearly states the tool's purpose: 'Find arbitrage opportunities on Polymarket via monotonicity violations + partition-sum checks.' It explicitly distinguishes three modes (no args, event, topic) and provides concrete examples, making it easy for an AI agent to understand what the tool does and how it differs from siblings like polymarket_fill_risk.

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

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

The description provides explicit usage guidance: 'Call with NO args for a trending_scan... pass event for the strongest per-event partition_check, or topic for a themed cross-event scan.' It also suggests when to use an alternative tool: 'For custom sizing use polymarket_fill_risk.' 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 indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds significant behavioral context: caching (1h KV-level), response segments (by_segment with three model families), diagnostics for empty segments, and edge conditions like Fed note and '24h-move warning'. It discloses internal logic and limitations (e.g., Fed signal reliability).

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 main purpose. Every sentence adds technical depth, though it could benefit from bullet points or clearer segmentation (e.g., model families, knobs, response structure). It is dense but not wasteful, earning a 4 rather than 5 due to slight verbosity.

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

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

Given 9 optional parameters, no output schema, and a complex multi-segment response, the description covers all essential aspects: output structure, segment definitions, filtering logic, diagnostics, and edge cases (e.g., Fed note). It leaves no major gaps for an agent to invoke the tool correctly.

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

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

Input schema coverage is 100% with detailed descriptions for all 9 parameters. The description adds value by explaining the rationale behind certain parameters (e.g., min_partition_leg_kelly clarifies that partition arbs return kelly_fraction_half=0 at parent level) and how knobs like min_liquidity and max_spread_pp affect tradeability. This exceeds the baseline of 3 for high coverage.

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

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

The description starts with a specific verb ('Scan') and resource ('Polymarket markets'), clearly stating the tool's action: returning opportunities where Pipeworx data disagrees with market price. It distinguishes itself from siblings like polymarket_arbitrage and polymarket_edge_tracker by focusing on discrepancy detection rather than arbitrage or tracking.

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 suggests usage with 'Built for "what should I bet on today"', implying a daily scanning use case. However, it does not explicitly state when not to use this tool versus alternatives like polymarket_arbitrage or polymarket_fill_risk. The guidance is implied through context but lacks direct exclusions or conditional comparisons.

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

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

Annotations already provide readOnlyHint, idempotentHint, and destructiveHint=false. The description adds behavioral context: snapshot gaps, bounded history, decay computed from daily closes. It does not contradict annotations and adds value beyond them.

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

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

The description is informative but slightly long. It front-loads the purpose and then details response fields. Some sentences could be condensed, but overall it is well-structured and earns its 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 low parameter count (2 optional parameters), 100% schema coverage, no output schema, and the tool's analytical nature, the description is thoroughly complete. It explains the response structure comprehensively (tracked, expired, snapshot_dates) and provides context for interpretation.

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 semantic value by explaining the 'days' parameter's default and clamp, and 'window' parameter's possible values. It also details the response structure, which provides meaning beyond the input 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-resource pair ('Edge persistence and decay telemetry') and clearly distinguishes from sibling tools like polymarket_edges by focusing on persistence/decay. It answers a concrete question ('how long has this edge existed and is it shrinking?'), leaving no ambiguity about 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 states when to use this tool (to understand edge persistence) and contrasts it with alternatives (a fresh wide edge vs. a 3-week-old one). It also provides usage context like the 14-day default lookback and max 30 days, and mentions limits (60-day TTL, snapshot gaps).

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

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

Annotations declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds substantial behavioral context: it 'walks the ladder', returns verdicts (clean|degraded|cannot_fill), and describes forced directional risk. No contradictions; description enhances transparency beyond annotations.

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

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

The description is dense and informative, but slightly verbose. It starts with a clear purpose, then breaks into modes. Every sentence adds value, but it could be more structured (e.g., bullet points) for easier scanning. Still, it's appropriately sized for a complex tool.

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

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

Despite no output schema, the description comprehensively lists all return values for both modes: top_of_book, vwap_fill_price, slippage_pp, shares_filled, max_fillable_usd, verdict for single-market; for basket: theoretical_sum vs realizable_sum, capture_ratio, profit_usd, per-leg fill detail, thin_legs, max_clean_notional_usd, forced_directional_risk. This fully covers the tool's output.

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

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

Schema coverage is 100%, but the description adds significant meaning: it explains the two modes (single-market vs basket), default values for side and size_usd, and the auto-detection logic for side in basket mode. It clarifies that size_usd in basket mode is 'settlement notional — shares per leg', which isn't obvious from the schema alone.

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

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

The description clearly states the tool performs a realizable-vs-theoretical edge check against live CLOB order-book depth, with explicit modes (single-market and basket). It distinguishes itself from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use this tool before acting on their signals.

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

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

The description explicitly says 'USE THIS before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500', providing clear when-to-use guidance. It also warns about the risk of partial fills converting an arb into an unhedged directional position, giving context for when not to use it without this check.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds extensive detail on output structure, safety fields (compatibility_warning, temporal_alignment, skipped counters), and conditions when spreads are meaningful. No contradiction with annotations.

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

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

The description is long but well-structured, front-loading purpose and modes, then response details, then safety warnings. Every sentence provides necessary context, though some redundancy could be trimmed (e.g., repetition of pre-mapped warning).

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

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

Despite lacking an output schema, the description fully explains response fields (leg-by-leg prices, spreads, compatibility_warning, temporal_alignment, skipped counters). All three parameters are covered, and safety nuances are addressed.

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 examples and descriptions. The description adds value by explaining mode logic and listing the 10 topic shortcuts, clarifying the relationship between parameters.

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

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

The description clearly states the tool computes cross-venue spreads between Kalshi and Polymarket for the same resolving question. It distinguishes from siblings like polymarket_arbitrage by focusing on inter-venue comparison.

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

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

Explicitly describes two modes (topic shortcuts and explicit tickers) and warns that pre-mapped topics often return compatibility warnings, implying when results may not be meaningful. However, it does not explicitly list alternative tools for single-venue analysis.

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

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

Annotations already declare readOnlyHint and idempotentHint. The description adds non-obvious behavior: omission of key lists all saved keys, and that retrieval is scoped to the agent's identifier. This is valuable beyond annotations.

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

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

Two sentences, each purposeful. No unnecessary words. First sentence states core function, second provides usage guidance and context.

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

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

With one optional parameter, no output schema, and clear annotations, the description fully covers how to use this tool. It explains purpose, usage, scope, and related tools, leaving no ambiguity.

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

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

The input schema has 100% coverage but the description adds critical behavioral context for the key parameter, especially the option to omit it to list all keys. The description complements the schema perfectly.

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

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

Clearly states the tool retrieves values saved via `remember` or lists all keys when omitted. Distinguishes itself from sibling tools like `remember` and `forget` by specifying its read-only retrieval 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?

Explicitly describes when to use: to look up previously stored context without re-deriving it. Also explains scope (scoped to identifier) and pairs with `remember` and `forget`, providing a complete usage picture.

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

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

Annotations declare readOnlyHint and idempotentHint. The description adds that mark_read:true flags events as read, a behavioral side effect beyond a simple read. It also details return fields (source, citation_uri, payload) and filter options, providing good context without contradiction.

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

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

The description is three focused sentences: purpose, return fields, filter/mark_read behavior, and polling/alternative URL. No fluff, all sentences add value, front-loaded with essential info.

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

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

Given no output schema, the description adequately covers return format (source, citation_uri, payload) and key behaviors (filtering, mark_read, polling). Missing details on error conditions or authentication, but sufficient for a simple read tool with high schema coverage.

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 5 parameters with descriptions (100% coverage). The description adds a concrete filter example ('sec_8k') and clarifies mark_read behavior, but does not significantly extend schema meaning. 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 pulls fired events from a subscription feed using the verb 'Pull' and specifies the resource as alerts/events. It distinguishes from siblings like list_subscriptions and recent_changes by focusing on event retrieval from a persisted feed.

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

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

The description implies usage for viewing recent alerts and mentions polling suitability and an alternative URL. It does not explicitly exclude other tools or provide when-not-to-use guidance, but the context is clear given sibling differences.

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

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

The description fully discloses behavior beyond annotations: fan-out to multiple sources, fallback logic (GDELT to GNews), soft-fail for USPTO, parameter formats, and return structure (grouped changes, total count, citation URIs). No contradictions with annotations.

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

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

The description is a single paragraph, front-loaded with usage examples, and efficiently covers multiple sources and parameters. Slightly dense but appropriately sized for a complex tool.

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

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

Even without an output schema, the description explains return values (grouped changes, total count, citation URIs) and source-specific details (SEC EDGAR, GDELT/GNews, USPTO limitations). Complete for the tool's complexity.

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

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

Schema coverage is 100%, but the description adds value by providing examples for `since` ("7d", "30d", "1y"), recommending typical values, and clarifying that `value` accepts ticker or CIK. This goes beyond the schema's basic descriptions.

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

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

The description clearly defines the tool's purpose as a change feed for companies over a recent time window, with explicit examples ("What's new with X", "latest on Y") and differentiation from sibling tool 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?

The description provides explicit when-to-use instructions (e.g., for recent activity) and when not to use (use entity_profile for static profile). It also gives usage tips like 'Use "30d" or "1m" for typical monitoring.'

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

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

Annotations already indicate idempotent and non-destructive. Description adds key behavioral context: scoped by identifier, persistent for authenticated users, 24-hour retention for anonymous. 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?

Single paragraph with efficient sentences. No waste; each sentence adds distinct information about purpose, usage, behavior, and related tools.

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 write-only tool with two string params and no output schema, the description fully covers what an agent needs: when to use, what it does, how data is stored, and how to retrieve/delete.

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

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

Schema coverage is 100%, so baseline 3. Description adds value by giving key examples ('subject_property', 'target_ticker') and clarifying that value can be any text. Not redundant.

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

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

Clearly states the tool saves data for reuse across conversations, with specific examples like 'resolved ticker' or 'user preference'. Differentiates from siblings (recall, forget) by naming them.

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

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

Explicitly advises when to use ('when you discover something worth carrying forward') and provides alternatives: 'Pair with recall to retrieve later, forget to delete.' Also mentions scope and persistence durations.

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, open-world, idempotent, and non-destructive behavior. The description adds valuable context: graceful degradation (LEI/FIGI unavailable, EDGAR still returns), explicit listing of unresolved identifiers, source labelling of identifiers, and internal cascading lookups. No contradiction with annotations.

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

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

The description is long but well-structured: starts with example queries, then states purpose, then details supported types in a clear section. It front-loads the key message 'Use FIRST...' and each sentence adds meaningful info (input forms, enrichment behavior, cascade benefit). Minor verbosity in the company parenthetical, but overall effective.

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

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

With no output schema, the description fully covers return values: company returns CIK, ticker, company_name, LEI with ownership, FIGI, and unresolved list; drug returns RxCUI, ingredient, brand, and citation. It also addresses failure modes (unavailable sources) and input permutations, making the tool usable without additional context.

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

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

Schema coverage is 100%, so baseline is 3. The description enhances parameter understanding with concrete examples (AAPL, 0000320193) and clarifies accepted input forms per type (ticker, CIK, or name for company; brand or generic for drug), going slightly beyond the schema's generic descriptions.

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

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

The description clearly states the tool resolves user-spoken names to canonical/official identifiers, with specific verbs ('resolve', 'look up') and resources ('identifiers'). It distinguishes from siblings by explicitly positioning it as the first tool to use when you have a name but need an ID.

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

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

The description provides explicit usage guidance: 'Use FIRST whenever you have a name but need an ID.' It also gives concrete example queries ('What's the ticker for…') and explains that it replaces 2-3 manual lookups, clearly indicating when to prefer 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 readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral details: probes each entity with ai_visibility_check, ranks by score, surfaces most/least recognized, and returns a ranked list with specific fields. No contradictions.

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

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

Two well-structured sentences. The first sentence states the core purpose (compare and rank). The second sentence adds behavioral detail and use case. Every sentence adds value with no fluff.

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

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

The tool has no output schema, so the description correctly explains return values (ranked list with score, confidence, signal density). It covers input parameters and behavior. However, it does not mention error handling, rate limits, or pagination, though these are less critical for a one-shot comparative 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 baseline is 3. The description adds substantial meaning beyond schema: clarifies that the first entity in the array is treated as the 'subject' for narrative, that context disambiguates common names, and that _apiKey is passed to api.anthropic.com per probe.

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

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

The description specifies the verb 'Compare', resource 'AI visibility across multiple entities', and differentiates from sibling tools like ai_visibility_check (single entity) and compare_entities (general comparison). It clearly states the output: ranked list with score, confidence, signal density.

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

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

The description provides explicit context ('competitive AI-marketing audits') and an example question ('does Claude know about us as well as our competitors?'). It implies when to use but does not explicitly state when not to use or list 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?

Discloses partial failures, timing (5-30s first measurement), and graceful degradation. Annotations already declare readOnly and idempotent; description adds behavioral nuance without contradiction.

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

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

Single paragraph is slightly long but every sentence is informative and front-loaded with core purpose. Minor improvement possible with structuring.

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

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

No output schema, but description fully enumerates return fields (summary, advisories, links, alternatives) and covers edge cases (partial failures, timing).

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

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

Schema coverage is 100%, so baseline 3. Description adds value by clarifying scoped packages and default version behavior, exceeding schema docs.

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

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

Description clearly states it's a composite check for npm package evaluation covering license, advisories, version history, and bundle analysis. It distinguishes from siblings by specifying the exact use case.

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

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

Explicitly says when to use (when agent asks safety/popularity/size questions) and limits to NPM ecosystem with alternative for other ecosystems.

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

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

Discloses internal mechanics: BGE-base-en embeddings, cosine similarity, 500-char overlapping windows, 200K char cap with truncation flag. Annotations provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds context beyond annotations without contradiction.

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

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

Description is moderately long (~100 words) but well-structured with front-loaded purpose. Each sentence adds value: use case, pairing, technical details. Could be slightly more concise by removing some example phrases, but overall efficient.

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

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

Covers purpose, usage guidelines, technical behavior, and parameter nuances. No output schema exists, but description hints at return format (passages with offsets). Lacks mention of error cases or performance, but sufficient for an agent to decide and invoke 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% (all params described). Description adds context: for 'text' it repeats the max length, for 'query' gives example queries. It also mentions that passages come with character offsets and similarity scores. While schema already defines params, the description enriches understanding of how the tool processes input.

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

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

The description clearly states 'Semantic search INSIDE a fetched record.' It provides concrete examples (SEC 10-K, article) and distinguishes from sibling ask_pipeworx_grounded by explaining how they pair. The verb 'search' and resource 'record' are specific.

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

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

Explicitly states when to use: 'Use when the record is too big to cram into the prompt.' It explains the benefit (saves context, returns only relevant passages) and pairs with ask_pipeworx_grounded for grounded verification. No explicit 'when not to', but the use case is well-defined.

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

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

Beyond annotations (readOnlyHint=false, idempotentHint=true), the description adds important behavioral details: requires OAuth, SMS 10/day cap, webhook auto-disabled after 10 failures, and signing secret returned once. No contradictions with annotations.

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

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

The description is well-structured, front-loading the core purpose, then detailing types and delivery in a scannable format. Every sentence provides unique value without redundancy.

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

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

Given the tool's complexity (3 parameters, nested objects, no output schema), the description covers authentication, all type-specific params, delivery options, and edge cases (SMS cap, webhook disabling), making it fully actionable.

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

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

The description significantly enriches the schema: it explains each subscription type with real examples (e.g., sec_8k items codes), clarifies delivery channels' constraints (phone verification, webhook signing), and adds nuance not in property descriptions.

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

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

The description clearly states the tool creates a proactive monitoring subscription, returns a subscription ID, and distinguishes itself from siblings like list_subscriptions and unsubscribe by its action and domain-specific details.

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 outlines prerequisites (Pipeworx OAuth account) and provides concrete examples for each subscription type and delivery channel, but does not explicitly contrast with alternative tools or state when not to use it.

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

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

Annotations already declare readOnly, openWorld, idempotent, non-destructive. The description adds key behavioral context: it returns categorized questions with exact tool+argument shapes drawn from a live catalog, and explains that no arguments gives full spread.

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 and front-loaded with common queries, but it is somewhat verbose with the list of categories and meta-tools. Still, 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, the description fully explains what is returned (category-bucketed examples) and how parameters affect output. Annotations cover safety and idempotency. No gaps remain.

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

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

Schema coverage is 100% for the single parameter 'topic', and the description adds value by explaining when to omit (full spread) vs. provide a focus area, listing example values like 'finance', 'pharma'.

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: returns category-bucketed example questions for exploring Pipeworx capabilities. It uses specific verbs like 'returns' and distinguishes itself from siblings by being the onboarding entry point, not a query 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 this FIRST when you do not yet know what Pipeworx can do for you' and provides trigger phrases (e.g., 'what can you do?'). It also hints at alternatives like meta-tools (ask_pipeworx, entity_profile).

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

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

Annotations provide readOnlyHint=false, destructiveHint=false, idempotentHint=true. The description adds that ownership is enforced, the row is deactivated (not deleted), and historical events stay available. This fully explains the behavioral nuance beyond the annotations and aligns with idempotency.

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

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

Two sentences with no wasted words. The first sentence states the core action and constraint; the second provides important nuance. The description is front-loaded and immediately useful.

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

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

For a simple one-parameter tool with no output schema, the description covers the action, ownership, deactivation behavior, and connection to recent_alerts. It could optionally mention the return value (e.g., success/failure), but overall it's thorough enough for the agent to invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description mentions 'by id' and ties it to 'subscription id (uuid) returned by subscribe,' but doesn't add new semantics beyond what the schema provides. A higher score would require extra details like format or examples.

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 'Cancel a subscription by id,' which clearly communicates the action and resource. It distinguishes from sibling tools like 'subscribe' (its inverse) and 'list_subscriptions' (listing), and explicitly mentions 'recent_alerts' for historical events, showing awareness of the tool ecosystem.

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

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

The description mentions ownership enforcement ('only cancel your own subscriptions') and implies the id comes from 'subscribe.' It doesn't explicitly state when not to use, but the context of deactivation vs. deletion is clear. An explicit alternative for permanent deletion is missing, but the guidance is solid.

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

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

The description goes well beyond the annotations by explaining the two distinct processing paths (structured SEC EDGAR vs. grounded pipeline), the exact verdict vocabulary, and the critical semantic distinction between could_not_verify and unsupported. It explicitly warns that could_not_verify is NOT evidence and must not be shown as one, which is high-value behavioral context. No contradiction with annotations.

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

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

The description is long but every sentence earns its place. It front-loads with user-facing trigger phrases, then covers purpose, routing logic, return values, error semantics, and the call replacement advantage. Despite its length, it is tightly structured and contains no fluff.

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

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

Given the tool's complexity, the description is remarkably complete. It covers both processing paths, all possible verdicts, the meaning of error and unsupported states, and the return format, even though there is no output schema. The annotations add safety context (read-only, idempotent) and the description fills all other 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?

While the schema already fully documents both parameters, the description adds meaningful context: it gives concrete examples for 'claim' (e.g., Apple revenue) and explains how tolerance_pct overrides the wording-implied default and is useful for hallucination detection. This adds value beyond the schema's bare definitions, though the schema already covers the basics.

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

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

The description opens with explicit natural-language triggers and a precise verb+resource: 'natural-language claim verification against authoritative sources.' It clearly distinguishes this tool from siblings by stating its exact role: checking factual correctness of user statements, with a structured fast path for company-financial claims and a grounded pipeline for everything else.

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 'use whenever' condition: the agent needs to check whether something a user said is factually correct. It also explains the tool replaces 4-6 sequential calls, which implies efficiency benefits. However, it does not explicitly state when not to use it or name alternatives (e.g., deep_research for broader questions), so it misses the 'when-not' guidance that would earn a 5.

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