Openchargemap

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

Annotations declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds behavioral details: default model (free Workers AI), need for _apiKey for Anthropic (BYO key), and return format. No contradictions.

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

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

Two short sentences front-load the purpose and default, then cover key details and use cases. Every sentence is essential with no wasted words.

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

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

Despite no output schema, the description details return format per-model and combined. All parameters are explained adequately for a tool of moderate complexity.

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

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

Schema coverage is 100% with descriptions for all 4 parameters. The description adds value by explaining default behavior for models, the role of _apiKey passed through to Anthropic, and context for disambiguation, going beyond schema.

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

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

The description uses a specific verb 'probe' and resource 'LLMs', clearly stating it scores visibility per model. It distinguishes from siblings by focusing on LLM probing for visibility, unlike scan_competitor_ai_presence which likely has a different 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 lists use cases like AI-marketing audits and brand checks, providing context for when to use. However, it does not explicitly state when not to use or compare with 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?

With annotations already declaring read-only, idempotent, and non-destructive behavior, the description adds meaningful context by explaining that the tool routes queries, fills arguments, and returns structured answers with pipeworx:// citations. This goes beyond the annotations without contradicting them.

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

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

The description is longer than the ideal but front-loads the most important directive ('PREFER OVER WEB SEARCH') and organizes content well: scope, mechanism, usage triggers, examples, and a closing 'START HERE' reminder. Some example duplication with the schema exists, but the structure is still effective.

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

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

The description covers input (natural-language question), behavior (routing, argument filling), and output (structured answer with citations), which is sufficient given the simple schema and no output schema. It does not explain how to choose among closely related sibling tools, but it is otherwise complete for an ask-style tool.

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

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

Schema coverage is 100%, with the single required 'question' parameter and five aliases all described. The description adds general guidance on phrasing ('natural language', example questions) but does not meaningfully enrich parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool's purpose: it answers factual questions by routing them to one of thousands of verified data tools and returning structured answers with citation URIs. It also distinguishes itself from web search, but it does not explicitly differentiate from sibling tools like ask_pipeworx_beta or ask_pipeworx_grounded.

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

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

The description gives explicit trigger phrases and examples ('what is', 'look up', 'current'), and instructs agents to prefer this tool over web search for factual questions. It lacks explicit when-not-to-use guidance or comparison against sibling research tools, but the conditions for use are clearly stated.

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

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

Beyond the read-only and idempotent annotations, the description discloses that this is a full working router with no fallback, currently behaving identically to ask_pipeworx, and that routing improvements are enabled live only when a candidate is under test. This is exactly the kind of beta-specific behavior an agent cannot infer from schema or 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 somewhat long but each sentence adds meaningful context: beta status, equivalence to the stable tool, current candidate state, and usage guidance. It is front-loaded and logically ordered, with only minor redundancy in restating the identical-arguments point.

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-required-parameter tool with no output schema, the description covers the essential operational facts: what it is, how it differs from ask_pipeworx, what the current behavior is, and whether it can be relied on as a full router. The same-response-shape statement substitutes for a missing output schema.

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

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

Schema description coverage is 100%, so the schema already documents the question parameter and its five aliases. The description adds only that arguments are the same as ask_pipeworx, which is useful but not necessary given the schema's completeness.

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

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

Description identifies the tool as a beta variant of ask_pipeworx, explicitly stating it is an identical universal router with the same 5,798 tools, arguments, and response shape. This clearly distinguishes it from the stable sibling ask_pipeworx and from more specialized siblings like ask_pipeworx_grounded.

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

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

It tells the agent to use it exactly like ask_pipeworx when the newest routing is desired, and notes results are compared with the stable router. It does not enumerate when-not-to-use cases, but the no-candidate-active and experimental-edge context makes the conditional clear.

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

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

Annotations already declare readOnly/openWorld/idempotent/non-destructive, and the description adds substantial behavior beyond that: the refusal contract with an explicit enum of refusal_reason values (not_in_source, no_tool_match, tool_error, data_truncated, llm_error), the verbatim-evidence guarantee, and the extra LLM call cost. This fully discloses how the tool behaves when data is insufficient — the key behavioral trait — with no contradiction of annotations.

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

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

The description is dense but every sentence earns its place: purpose, mechanism, return shapes, refusal reasons, usage rules, and cost tradeoff. It is front-loaded with the core identity and routes to behavior details after. The refusal-format enumeration is long, but with no output schema present it is essential information rather than padding.

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 — routing across 5,798 tools with conditional refusal — the description is remarkably complete. It covers success and failure return shapes (critical since there is no output schema), the cost/latency tradeoff versus the sibling, when to use it, and when not to. Nothing an agent needs to select and invoke the tool correctly is missing.

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

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

Schema coverage is 100% and the schema already documents the single semantic parameter 'question' plus its five aliases. The description mentions that the tool "fills arguments" as part of routing, which gives light operational context, but it does not add meaning beyond the schema for the parameter itself. Baseline 3 is appropriate under high schema coverage.

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

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

The description opens with a specific identity — "Hallucination-resistant answer mode for high-stakes reads" — and then precisely describes the mechanism: route, fetch, and extract using ONLY tool-result content. It explicitly contrasts with ask_pipeworx ("Same routing as ask_pipeworx") while clarifying that the difference is the grounded extraction step, so an agent can distinguish it from every sibling without opening schemas.

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

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

Usage guidance is explicit and actionable: "Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts," followed by concrete domains (financial verdicts, legal claims, medical lookups, public statements). It also names the exclusion condition and alternative: "prefer ask_pipeworx for casual lookups." This is a textbook when/when-not/alternative statement.

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=true (non-destructive). The description adds extensive behavioral context: resolver contract with match confidence, parent event extractor, news fields with fallback handling, safety short-circuits for low confidence and closed markets, wide-spread market handling, and resolution-rule risk analysis. These details go well beyond what annotations provide.

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

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

The description is informative but quite long and dense. It front-loads the main purpose but then presents many details in a paragraph format. While the depth is valuable, the structure could be improved with bullet points or clearer separation of sections for easier scanning. Some sentences could be shortened.

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

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

Given the complexity (3 parameters, no output schema, many behavioral nuances), the description covers nearly all relevant aspects: input types, processing steps, response structure, edge cases, and safety considerations. The only minor gap is the lack of explicit output schema, but the description compensates by detailing response shapes.

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

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

Schema coverage is 100% with all parameters described. The description adds significant value beyond the schema: it explains the 'market' parameter can be a slug, URL, or question text; details the 'depth' parameter with default; and explains 'include_raw' with use cases for when to set it true vs false. This helps the agent understand parameter usage and defaults.

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

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

The description clearly states the verb 'research' and the resource 'Polymarket bet via Pipeworx data'. It distinguishes itself from sibling tools by focusing on betting research, market resolution, classification, fan-out to data packs, and evidence packet with comparison.

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

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

The description provides explicit use cases: 'should I bet on X', 'what does the data say about Y', or 'is there edge in Z'. It also gives examples of fan-outs for different bet types. However, it does not explicitly mention when not to use this tool or suggest alternatives among siblings, though the context implies its specific role.

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 read-only and idempotent; description adds that it makes a single parallel call, handles differing fiscal years, sorts results by primary metric, and returns citation URIs.

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

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

Front-loaded with query examples, each sentence adds value, no redundancy, efficient for amount of 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 no output schema and complexity, description covers data sources, sorting, citation URIs, and explicitly replaces multiple lookups, making it complete for agent understanding.

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

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

Schema coverage is 100%, baseline 3. Description adds meaning by explaining what data type='company' pulls (latest 10-K metrics) and type='drug' pulls (FAERS, FDA, trials), but could be more precise on output format.

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

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

The description uses specific verb 'side-by-side comparison' and resource entities (companies/drugs), provides example queries, and distinguishes from sibling tools by stating 'ALWAYS PREFER over sequential single-pack lookups'.

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

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

Explicit guidance to prefer over sequential lookups, clear context on when to use (comparing multiple entities) and what each type retrieves, with examples of queries.

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

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

Annotations already mark this read-only, idempotent, and open-world; the description adds substantial behavioral context: auth and paid-tier requirements, parallel decomposition, findings packet contents, citations that are always fetchable, explicit gaps[] rather than invented answers, contradictions[] on standard/thorough, semantic excerpting, and latency expectations. This goes far 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 long but information-dense; nearly every clause adds operational guidance rather than filler. It front-loads the critical account requirement and the core distinction from open-web search before moving into findings format and depth behavior. It could be tightened into clearer sections, but the density is justified for a tool with no output schema.

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

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

There is no output schema, so the description carries the full burden of explaining what the agent will receive: verbatim evidence, confidence, source, fetched_at, pipeworx:// citations, hop field, gaps[], and contradictions[]. It also covers auth prerequisites, tool latency, and how citations resolve, making the tool fully actionable without needing outside knowledge.

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 question and depth are already fully documented. The description adds value on top by explaining the behavioral differences between depth levels (gap recovery, contradiction scan, paid tier) and by noting that broad/multi-part questions are appropriate for the question parameter.

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

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

States a specific action and resource: grounded multi-source research across Pipeworx's 1517 structured data sources in one call, with decomposition and parallel tool routing. It also explicitly distinguishes itself from open-web search and from the ask_pipeworx sibling for single lookups, so an agent can tell it apart from its siblings.

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

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

Provides explicit when-to-use and when-not-to-use guidance: best for broad/multi-part structured-data questions, and for single lookups it directs the agent to ask_pipeworx instead. It also handles the signed-out case by naming ask_pipeworx as the fallback that works on every tier.

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 safe, idempotent, non-destructive behavior. The description adds beyond: returns top-N tools with full schemas and examples, ready to call directly, no second schema lookup. No contradictions with annotations.

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

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

The description is a single paragraph but efficiently covers purpose, supported domains, return format, and usage guidance. It is front-loaded with the core action. Minor redundancy in listing aliases (already in schema), but overall well-structured.

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

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

Given no output schema, the description adequately explains return structure (top-N tools with schemas/examples). It covers purpose, usage, and result format. Missing details like error handling or rate limits, but for a safe discovery tool, this is sufficient.

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

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

Schema coverage is 100% (all parameters described), so baseline 3. Description adds value by summarizing alias acceptance, giving natural language examples, and clarifying limit defaults/max. This enhances understanding beyond schema.

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

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

The description clearly states the tool finds tools by describing data or task, listing specific domains. It distinguishes itself from siblings by positioning as a meta-discovery tool to be called first ('Call this FIRST when you have many tools available'), differentiating from direct answer or search 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 advises using this tool when wanting to browse or discover options, especially with many tools available. It does not explicitly name alternatives or when not to use, but the context 'not just one answer' implies exclusion of single-answer scenarios.

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

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

The description goes well beyond the annotations by disclosing that this fans out across many sources, returns sources_used/sources_failed, treats empty sections as real 'no data,' resolves names via SEC EDGAR, and returns resolved:false with a notes line for private companies. This gives an agent accurate expectations about behavior and failure modes without contradicting the readOnly/idempotent hints.

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

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

The description is dense and information-rich but presented as one long, run-on paragraph with many parentheticals and examples. It front-loads the key purpose but would benefit from clearer structure. Every sentence contributes value, yet the overall length and format make it harder to parse quickly.

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

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

Given no output schema exists, the description carries the burden of explaining return values, and it does so thoroughly: it lists major result sections, source fan-out, URI formats, failure signaling, private-company behavior, and input variants. For a complex tool, this is a complete and actionable description.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaningful semantics: type accepts 'company' or 'ticker' interchangeably, value may be a ticker, zero-padded CIK, or company name, and name resolution behavior is explained. These details go beyond the schema descriptions and clarify real invocation choices.

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

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

The description clearly states a specific verb and resource: it produces a 'full cross-source profile of a US public company in ONE parallel call.' It also differentiates itself from simpler SEC/XBRL/news lookups by explicitly preferring this tool for holistic company questions, so an agent can distinguish it from narrower siblings.

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

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

The description gives explicit guidance: 'ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view.' It also specifies acceptable input forms (ticker, CIK, company name) and what happens for private companies. It does not explicitly contrast with all possible siblings like compare_entities or deep_research, but the intended use case is clearly scoped.

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

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

Adds value beyond annotations by describing automatic geocoding, return fields (operator, status, connector types, speed, distance), and filtering capability. Annotations already cover safety; description enhances behavioral understanding.

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

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

Four sentences, front-loaded with purpose, then input method, then output, then filter. No redundant information; 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?

Covers main aspects: purpose, input options, returned data, filtering. Lacks mention of defaults (radius, max_results) and pagination, but schema covers those. Adequate for a tool with 9 params and no output schema.

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

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

Schema description coverage is 100%, so baseline is 3. Description adds some clarity (e.g., location input modes) but mostly reiterates schema content without significant extra 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?

Clearly states 'Find EV charging stations near a place' using a specific verb and resource. Distinguishes from sibling 'get_station' which is for a single station.

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 find stations near a location, with options for location name or lat/lng, and optional filtering. Does not explicitly mention alternatives but effectively communicates its primary use case.

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, but description adds value by explaining triggers (stale context, task done) and clarifying it clears sensitive data, enhancing behavioral understanding.

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?

Extremely concise with two sentences. Front-loaded with action and purpose, then usage guidelines. No wasted words.

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

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

Given low complexity (single parameter, no output schema, clear annotations), the description is fully complete: covers purpose, usage, and relationships to siblings.

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

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

Only one parameter 'key', with schema description 'Memory key to delete'. Schema coverage is 100%, so description does not add additional semantics beyond the schema, meeting 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?

Description uses specific verb 'Delete' and clear resource 'previously stored memory by key'. It distinguishes from siblings by mentioning 'Pair with remember and recall', making purpose unambiguous.

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

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

Explicitly states when to use: 'when context is stale, the task is done, or you want to clear sensitive data'. Does not explicitly state when not to use, but provides clear context and 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 behavioral details like fetching the page, extracting content, and emitting markdown, which complements the 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?

The description is a single paragraph of approximately three sentences, front-loaded with the action and purpose. Every sentence adds value, and there is no wasted verbiage.

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 two parameters, high schema coverage, and rich annotations, the description provides all necessary context: what it does, how it works, and concrete use cases. No output schema is needed as the result is a straightforward text blob.

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 does not add additional meaning beyond what the schema provides. The purpose of the URL and max_links is clear from the schema descriptions.

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

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

The description clearly states the verb 'Generate', the resource 'llms.txt file for any URL', and the purpose of indexing for AI crawlers. It also distinguishes from sibling tools by focusing on a specific output format.

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

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

The description provides explicit use cases: getting a client's site indexed, drafting for own project, or auditing competitors. It does not mention when not to use, but given the tool's specificity, this is sufficient.

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

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

Annotations already provide read-only and idempotent hints, so the bar is lower. The description adds value by detailing the return fields (connector types, speed, operator, status, comments, date). No contradictions with annotations.

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

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

The description is two sentences with no fluff. First sentence states purpose and parameter, second lists return fields. Every sentence earns its place, and key information is front-loaded.

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

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

For a simple single-item retrieval tool with two parameters and no output schema, the description adequately explains input and output. It could mention error cases but is otherwise complete.

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

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

Schema description coverage is 100% with clear descriptions for both parameters. The description does not add new semantic meaning beyond the schema; it reinforces the 'id' parameter role. Baseline score of 3 applies.

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

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

The description clearly states the verb 'Get', the resource 'full detail for a single EV charging station', and the required parameter 'Open Charge Map POI ID'. It distinguishes itself from the sibling tool 'find_stations' which likely lists multiple stations.

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 context by requiring a POI ID from 'find_stations', but it does not explicitly state when to use or not use this tool versus alternatives. The guidance is clear but not exhaustive.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. Description adds the return structure but does not disclose additional behavioral traits beyond annotations.

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

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

Two sentences: first states purpose and outputs, second provides usage guidance. No superfluous information.

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

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

For a simple tool with one optional parameter and no output schema, the description lists all return fields and provides usage context. Complete given annotations.

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

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

Schema coverage is 100% and includes a description for the only parameter. Description does not add meaning beyond the schema.

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

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

The description clearly states 'List the caller's active subscriptions' and enumerates returned fields. It distinguishes from sibling tools 'subscribe' and 'unsubscribe' by focusing on listing.

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

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

Provides explicit usage context: 'Use this to review what you're monitoring before adding more or to find an id to cancel.' Does not mention when not to use, but context is sufficiently clear.

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

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

Annotations already mark the tool as non-read-only (readOnlyHint=false), and the description adds substantial context: claim_token return flow, rate limit of 5 per identifier per day, free usage, and team review practices. No contradiction with annotations; the description enriches beyond structured metadata.

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 purpose and each sentence adds value (scope, exclusions, claim_token flow, rate limits). It is not wasteful, though somewhat verbose; a tighter version could merge some clauses without losing meaning.

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

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

With no output schema, the description clearly explains what the tool returns ('a claim_token') and how to follow up. It also covers limitations (foreign MCP servers, rate limit), making it complete 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%, so baseline is 3. The description adds useful param-level behavior, such as how claim_token works for later retrieval and that message should reference Pipeworx tools/packs rather than pasting user prompts. This lifts it above baseline but still relies mostly on the schema for param specifics.

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 opens with a clear verb+resource ('Tell the Pipeworx team something is broken, missing, or needs to exist') and enumerates specific feedback categories (bug, feature/data_gap, praise). It also distinguishes itself from siblings by explicitly scoping to tools served by this Pipeworx connection, avoiding confusion with other MCP servers.

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

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

Provides explicit when-to-use guidance: 'Use when a tool returns wrong/stale data (bug), when a tool you wish existed isn't in the catalog (feature/data_gap), or when something worked surprisingly well (praise)'. It also states when not to use and names the alternative ('file it with that server instead'), plus warns against pasting end-user prompts.

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 and idempotency. Description adds caching details (5min-1h), data source (CF analytics-engine), no PII, and explains that shorter windows surface current hotness while longer show steady-state demand.

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

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

Well-structured with front-loaded purpose, followed by use cases, then technical details. No fluff, each sentence adds value; could be slightly more concise but still 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?

With one parameter and full schema coverage, description explains return structure (top tools, top packs, total call volume), caching, and use cases. No output schema needed as return is self-explanatory.

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 window parameter with enum, but description adds interpretive context: shorter windows for 'what's hot right now', longer for 'steady-state demand', adding value beyond enum values.

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

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

Clearly states it returns top tools, top packs, and total call volume over a recent window, with a specific verb 'returns' and resource 'Pipeworx trending'. Distinguishes from siblings like discover_tools by focusing on what other AI agents are using.

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

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

Explicitly lists three use cases (discovering hot data sources, confirming popular tool, seeing alignment). Does not exclude alternatives but provides clear context for when 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 indicate readOnlyHint, idempotentHint, destructiveHint false. Description adds context: performs scans, uses semantic anchor, partition filter, fill check. It discloses that returns null arb signal under certain conditions. 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 verbose but well-structured with sections (modes, semantic anchor, partition filter, response, fill check). It is front-loaded with the main purpose. For a complex tool, this level of detail is justified, though some redundancy could be trimmed.

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

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

Given the complexity (arbitrage detection, multiple modes, fill check) and absence of output schema, the description thoroughly explains inputs, modes, and expected response fields (opportunities array, partition check details). It also covers edge cases like placeholder slugs and fill check logic.

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

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

Both parameters have schema descriptions (100% coverage). The description adds significant meaning: explains what each mode does, gives example values, and describes underlying logic (e.g., semantic anchor, partition filter). Far beyond the schema's basic descriptions.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It distinguishes two modes (event and topic) and mentions fill check. The verb 'find' and resource 'arbitrage opportunities on Polymarket' 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 says 'Call with NO args for a trending_scan' and explains when to use `event` vs `topic` with examples. Recommends `event` for specific markets and `topic` for cross-event scanning. Provides guidance on when not to trade via fill check and suggests alternative tool for custom sizing.

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

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

Annotations already declare readOnly, idempotent, non-destructive. Description adds details: edge_pp_net after slippage, kelly fractions capped at 0.25, liquidity/spread/volume, 24h-move warning, and caching. 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?

Very verbose and dense with technical jargon (e.g., 'placeholder-slug filter drops will-person-X / will-team-Y...'). While front-loaded with purpose, the extensive detail could overwhelm; some information (e.g., specific α values) could be summarized.

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 explicitly defines response structure: by_segment with three segments, fed_candidates/fed_note, and diagnostics (funnel counters, category_counts, filter_skips). Caching policy is stated. Fully covers the tool's behavior given 9 parameters and complex logic.

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?

All 9 parameters are fully described in schema (100% coverage). Description adds practical semantics: explains min_kelly skips small opportunities, min_edge_pp net of slippage, slippage_pp default justification (zero fees but bid/ask), and typical values for tradeable-edge filters (e.g., 'Set to 2 to require tight books').

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 it scans Polymarket markets for discrepancies between Pipeworx data and market price. Describes three specific segments (model-driven, structural arbitrage, concentrated longshot), distinguishing it from siblings like polymarket_arbitrage and polymarket_edge_tracker.

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 targets 'what should I bet on today' discovery, avoiding pagination. Describes tradeable-edge knobs (min_liquidity, max_spread_pp) but does not explicitly state when to avoid or compare to alternatives, though context implies usage for edge discovery.

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, etc.), description adds critical context: history bounded by 60-day TTL, snapshots written on cache-miss causing gaps, decay computed from daily closes (not intraday). No contradiction with annotations.

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

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

Description is verbose but well-structured: opens with purpose, lists args, then breaks response into tracked[], expired[], snapshot_dates[] sections, followed by LIMITS. Every sentence adds value, though some details could be more terse.

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

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

Given no output schema, description fully explains return structure and field semantics (e.g., trend, decay_pp_per_day, lifespan_days). Covers limitations and data freshness. Complete for a complex tracking tool.

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

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

Schema coverage is 100% with clear descriptions. Description adds extra context: clarifies days default 14 and clamp 2-30, window default '1wk' and snapshot family concept. Adds value beyond schema definitions.

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

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

Description clearly states it provides 'edge persistence and decay telemetry' and answers a specific question about edge duration. It distinguishes itself from sibling tools like polymarket_edges by focusing on temporal tracking, not just current edges.

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

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

The description implies usage for historical edge analysis but does not explicitly state when to use this tool vs. alternatives like polymarket_edges or polymarket_arbitrage. No guidance on when not to use or preferred contexts is given.

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

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

Annotations already indicate readOnly, openWorld, idempotent, non-destructive. Description adds behavioral context: requires one of market/event, explains walking the ladder, returns verdicts and risk analysis, and warns about directional risk. No contradictions.

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

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

Description is dense but well-structured with clear sections (SINGLE-MARKET, BASKET) and front-loaded purpose. Every sentence adds information; however, it could be slightly more concise by combining some phrases.

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

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

For a financial risk-check tool with 4 parameters and no output schema, the description thoroughly explains all parameters, return fields, and risks. It covers single and basket modes, edge cases (thin legs, partial fills), and provides practical usage 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 has 100% coverage, baseline 3. Description adds context: side defaults for each mode, size_usd interpretation (max spend vs target proceeds), basket size as settlement notional, and clamp range (10–1,000,000). Adds value beyond schema.

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

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

The description clearly states it performs a 'Realizable-vs-theoretical edge check against live CLOB order-book depth' and distinguishes between single-market and basket modes with detailed return fields. It differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use this 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 before acting on any polymarket_arbitrage SELL/BUY-EVERY-LEG signal or any polymarket_edges trade above ~$500' and explains risks (partial basket fills convert arb to unhedged position, thin books). Provides clear when-to-use and when-not-to-use guidance.

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

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

The description goes far beyond the annotations, disclosing that returned pairs can carry compatibility warnings, that temporal_alignment null means unknown rather than aligned, that spreads are gross and exclude Kalshi's fee schedule, and that pairing is keyword-based and unverified. This is rich, honest behavioral disclosure that contradicts nothing in the annotations.

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

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

The description is dense and information-rich but verbose, with run-on sentences and some redundancy (e.g., restating that both modes run the identical matcher). It uses useful labels (TWO MODES, RESPONSE, SAFETY FIELDS) and front-loads the core purpose, but it could be tightened without losing substance.

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 there is no output schema, the description carries the full burden of explaining the return structure, flags, semantics, and edge cases — and it does so exhaustively: top_spreads_pp, compatibility codes, skipped counters, low-confidence pairs, and fee disclosures are all covered. Nothing critical is missing for an agent to understand and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining how topic maps to events, how explicit parameters override the topic-mapped side, and that both modes run the same matcher. This is meaningful added context, not mere schema repetition.

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

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

The description states a specific verb and resource: 'Cross-venue spread between Kalshi and Polymarket for the same resolving question.' It is clear and specific, but it does not explicitly contrast itself with sibling tools like polymarket_arbitrage, leaving the differentiation largely implicit.

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 clearly explains the two modes (topic vs explicit pairing) and provides strong guidance on when results are reliable, including the warning that pre-mapped topics often return compatibility_warning and are not necessarily tradeable. It does not explicitly name alternative tools, but within-tool usage context is strong.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. Description adds scope detail (scoped to identifier) and behavior when key omitted (list all keys). 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?

Three concise sentences with no wasted words. Action is front-loaded. Each sentence adds distinct value: function, use case, scope, pairing advice.

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 single optional parameter, robust annotations, and no output schema, description covers all essential aspects: retrieval, listing, scope, and relationship to sibling tools.

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 parameter description already explains omission behavior. Description adds example usage and clarifies the effect of omitting key, providing context 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?

Description clearly states the two modes: retrieve a specific value via key or list all keys when key omitted. Uses precise verbs 'retrieve' and 'list'. Differentiates from sibling tools 'remember' and 'forget' by explicitly pairing with them.

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

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

Explicitly states when to use: 'to look up context the agent stored earlier... without re-deriving it from scratch.' Provides alternatives: 'Pair with remember to save, forget to delete.' Also implies when not to use (when saving or deleting needed).

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=true, but description states mark_read:true flag events as read, which is a state change. This contradiction undermines transparency. Description does add context about returned fields and polling suitability, but the contradiction is significant.

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, dense paragraph without wasted words. It front-loads purpose and includes all key points, but could benefit from slightly more structure (e.g., bullet points for return fields).

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

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

For a read tool with 5 optional params and no output schema, the description covers return structure, filtering, read-state management, polling, and alternative access. Minor gap: no explicit mention of result format (array) or pagination beyond the limit parameter.

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

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

Schema coverage is 100%, so baseline is 3. Description adds an example for type ('sec_8k') and clarifies mark_read usage, but does not substantially enhance understanding beyond schema descriptions.

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

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

The description clearly states the verb 'Pull fired events' and resource 'from your subscription feed', specifying what is returned (source, citation_uri, payload) and filtering options. It distinguishes from sibling tools by focusing on subscription feed alerts.

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

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

Description gives explicit usage guidance: filtering by type and since, using mark_read to manage read state, and polling suitability. It also provides an alternative direct HTTP endpoint for scripts/dashboards, helping the agent choose the right approach.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds significant behavioral details beyond annotations: fan-out to multiple sources, rate-limit handling (GDELT→GNews fallback), USPTO soft-fail due to API sunset, and return structure (changes grouped by source, total_changes count, pipeworx:// URIs). No contradiction.

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

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

The description is somewhat long but well-structured, with clear sections for data sources, parameter details, and fallback behavior. Every sentence adds value, and it is not excessively verbose for the complexity of the tool.

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

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

Given the complexity (three data sources, parameter details, fallback behavior) and lack of output schema, the description is remarkably complete. It explains what the tool returns (structured changes grouped by source, total_changes count, pipeworx:// URIs) and notes the patent soft-fail. 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. The description adds meaning: `type` is limited to 'company', `since` accepts ISO or relative shorthand with a recommended value ('30d' or '1m'), and `value` can be a ticker or CIK. This enhances understanding beyond the schema.

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

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

The description clearly states the tool's purpose as a change feed for a company over a recent time window, with explicit example queries and mention of data sources (SEC EDGAR, GDELT/GNews, USPTO). It differentiates from the sibling tool entity_profile, which is for static profiles.

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

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

The description provides explicit usage examples (e.g., 'What's new with X') and gives guidance on when to use an alternative: 'Use entity_profile instead when you want the static profile'. It also explains fallback behavior and soft-fail conditions, offering clear context for tool selection.

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

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

Annotations indicate idempotentHint=true and destructiveHint=false, which are consistent with the description. The description adds value by explaining persistence scoping (authenticated vs anonymous) and session duration, providing behavioral context 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), front-loaded with purpose, and every sentence adds value. No fluff or redundancy.

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

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

For a simple key-value store tool with no output schema, the description is sufficiently complete. It covers purpose, usage, persistence, and related tools. Minor gap: no mention of error handling or confirmation, but not critical for this tool.

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

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

Schema coverage is 100% with clear descriptions. The description adds examples of key-value pairs but does not significantly enhance the semantic meaning beyond what the schema already provides. 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 starts with 'Save data the agent will need to reuse later', clearly stating the verb and resource. It distinguishes from sibling tools by explicitly mentioning recall and forget, and provides specific examples of what to store.

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 specifies when to use the tool: 'when you discover something worth carrying forward', with concrete examples. It also clarifies behavior differences between authenticated and anonymous sessions, and explicitly pairs with recall and forget for retrieval and deletion.

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

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

Even though annotations already mark the tool read-only and idempotent, the description adds substantial behavioral context: it cascades through multiple lookup endpoints, degrades gracefully if LEI/FIGI sources are unavailable, explicitly marks unresolved identifiers, and returns candidates rather than asserting matches for ambiguous names. There is no contradiction with the annotations.

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

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

The description is long and dense, but well structured: core purpose first, then per-type details, then failure behavior. Every section delivers useful operational detail. It loses a point for verbosity and some redundancy in the company-type paragraph, but the organization makes it navigable.

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

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

Given the tool's complexity and the absence of an output schema, the description is remarkably complete. It covers accepted input forms, output labeling with sources, unresolved-identifier behavior, ambiguity handling, enrichment limitations, and even the underlying rationale for returning candidates. An agent has enough context to know when and how to invoke it correctly.

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

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

Schema coverage is 100%, so a baseline of 3 applies. The description adds meaningful semantic depth beyond the schema by warning to pass the entity name only, clarifying that bond issuers must be passed exactly as printed, and explaining that trailing security-class words will fail to match. This is useful extra guidance, though the schema already lays out the basic parameter meanings.

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 concrete, actionable verb: 'resolve a user-spoken NAME to the canonical/official identifiers other tools require as input.' It enumerates the supported types (company, drug) and the identifier families (CIK, LEI, FIGI, RxCUI), and explicitly positions itself as the first step when an ID is needed. This clearly distinguishes it from sibling tools like entity_profile or compare_entities.

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

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

It gives explicit guidance: 'Use FIRST whenever you have a name but need an ID.' It also explains when results are intentionally not asserted, such as ambiguous FIGI matches. However, it does not explicitly name when-not-to-use alternatives or what to use instead when the goal is deeper entity research rather than identifier resolution.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds that it internally probes each entity with ai_visibility_check, ranks by score, and returns a ranked list with score, confidence, and signal density—useful behavioral detail 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 two sentences: the first states the core action, the second adds context and output details. Every sentence earns its place with no wasted words.

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

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

Given 4 parameters, no output schema, and no nested objects, the description fully explains the process (probes with ai_visibility_check, ranks, returns list) and the output structure. It also provides an example use case, making it complete for an AI agent.

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

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

Schema coverage is 100% with each parameter described. The description adds that the first entity is treated as the subject and the rest as competitors, which is not in the schema. Also notes the return format (score, confidence, signal density) providing additional meaning.

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 compares AI visibility across multiple entities side-by-side, using specific verbs like 'compare', 'probes', 'ranks', and 'surfaces'. It differentiates from sibling ai_visibility_check by being a multi-entity, comparative tool.

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

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

The description provides a clear use case ('competitive AI-marketing audits') and an example question, implying it should be used when comparing recognition across brands. It doesn't explicitly state when not to use it or name alternatives, but the context is strong.

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

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

Description adds significant value beyond annotations: composite call fans out across two services, returns specific fields, handles partial failures gracefully (bundlephobia timeout), and lists alternative versions. No contradiction with annotations.

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

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

Single paragraph of 4-5 sentences, front-loaded with main purpose, then details. 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?

No output schema, but the description thoroughly lists return fields (summary block, per-advisory, links, alternatives) and failure behavior. The tool is complex with two services, but the description covers all essential aspects.

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 both parameters. The description adds little beyond the schema, but it reiterates version default and scoped package acceptance, which is consistent. 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 it's a composite check for evaluating npm packages, with specific verb 'scan' and resource 'dependency'. It distinguishes itself from sibling tools by its specific use case and composite nature.

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 an agent asks "is X safe / popular / small" or "what does adding lodash cost me"'. Also clarifies scope limitations (NPM only) and provides alternatives for other ecosystems via deps.dev:version.

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 embedding model (BGE-base-en), similarity metric (cosine), windowing (500-char overlapping), cap (200K chars with truncation flag), and that passages carry offsets for verification. Annotations already mark it as safe/idempotent, and description adds rich behavioral detail 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?

Four well-structured sentences, front-loaded with core purpose, each sentence adds distinct value (function, usage, pairing, technical details). No redundant or unnecessary content.

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

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

Without output schema, description explains return value (top-N passages with offsets and scores). Also covers truncation behavior, making it fully actionable for an agent.

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

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

Schema coverage is 100%, but description enriches parameters with usage context: 'text' is a previously fetched document, 'query' includes natural-language examples, 'limit' is max passages. Adds value beyond schema.

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

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

Clearly states semantic search inside a fetched record, specifies inputs (text+query) and outputs (passages with offsets and scores). Distinguishes from siblings by explicitly pairing with ask_pipeworx_grounded.

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

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

Explicitly says 'Use when the record is too big to cram into the prompt' and suggests pairing with ask_pipeworx_grounded. Provides clear context-aware guidance.

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

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

Beyond annotations (idempotentHint=true, etc.), the description reveals behavioral details: returns subscription ID, always-on feed, optional email/SMS/webhook with constraints (SMS cap, phone verification, webhook signing secret one-time, auto-disable). 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?

Well-structured with front-loaded purpose. Each sentence adds value, though slightly lengthy; could be more concise but remains clear and informative.

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

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

Given complexity (3 params, enums, nested objects, no output schema), the description covers return value (subscription ID), all type-specific params, delivery details, and limitations. Fully complete for agent 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%, baseline 3. The description adds meaningful context: explains each subscription type with examples and delivery field constraints, enhancing understanding beyond the schema.

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

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

The description clearly states the tool creates a proactive monitoring subscription to a live-data event stream. It distinguishes from sibling tools like list_subscriptions and unsubscribe.

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

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

Provides explicit context: requires Pipeworx OAuth account, not for anonymous/BYO, lists supported types and delivery channels. Lacks explicit when-not-to-use statements but offers sufficient guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, destructiveHint. Description adds that it returns example questions and can be focused by topic, but does not reveal unexpected behaviors 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?

Well-structured with front-loaded identification; slightly verbose but every sentence adds value.

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

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

All needed context is present: entry point usage, output format, parameter behavior, and when to use. No gaps given the simple nature of the tool.

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

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

Schema covers parameter meaning 100%, but description adds value by explaining the effect of omitting vs passing topic, and lists possible values in narrative form.

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

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

The description clearly states it is the onboarding entry point that returns category-bucketed example questions with tool shapes, distinguishing it from siblings like ask_pipeworx or discover_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?

Explicitly advises using this FIRST when unsure what Pipeworx can do, and to learn meta-tool calls. Does not provide exclusions but gives clear context for use.

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

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

Annotations already indicate non-readonly, non-destructive, idempotent. The description adds context about ownership enforcement and soft-delete (deactivation), which aligns with annotations and provides additional behavioral detail.

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

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

Two sentences, no fluff. Front-loaded with the action and then provides key details. Every sentence earns its place.

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

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

For a simple tool with one parameter and no output schema, the description covers purpose, behavior, ownership, side effects, and relation to 'recent_alerts'. Complete and self-contained.

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

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

Schema coverage is 100% and the schema already describes the 'id' parameter as a uuid returned by subscribe. The description adds no significant extra meaning beyond that.

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

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

The description clearly states the verb 'Cancel' and the resource 'subscription by id'. It distinguishes from sibling tools like 'subscribe' (opposite) and 'list_subscriptions' (listing).

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

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

The description gives clear context: ownership is enforced (only cancel own subscriptions) and explains the deactivation behavior. However, it does not explicitly state when not to use or name alternatives.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive. The description adds crucial behavioral nuance beyond these: it explains that 'could_not_verify' means the check did not happen and must not be treated as evidence, and 'unsupported' means no source covers the claim. This is valuable context for correct interpretation of results.

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

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

The description is fairly long but well-structured and every sentence carries information. It front-loads trigger phrases and core purpose, followed by behavioral details. Could be slightly tightened by trimming some examples, but it remains reasonable for the complexity.

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

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

Despite lacking an output schema, the description thoroughly explains return values: the verdict list (confirmed, approximately_correct, refuted, inconclusive, unsupported, could_not_verify), inclusion of grounded/structured actual values with citations, and reasoning. It also covers error semantics, making it complete for agent decision-making.

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

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

Schema coverage is 100% with descriptions for both 'claim' and 'tolerance_pct'. The description adds meaning beyond the schema by explaining that tolerance_pct overrides the tolerance implied by claim wording, giving a default cap of 5, and specifying use cases like hallucination detection (1–2).

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 natural-language claim verification against authoritative sources, with explicit example queries like 'fact check' and 'verify the claim that…'. It distinguishes itself from general Q&A siblings by focusing on factual claim verification and specifies two distinct processing paths.

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

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

The description explicitly says 'Use whenever the agent needs to check whether something a user said is factually correct', and it differentiates when to use the SEC EDGAR fast path versus the general grounded pipeline. It also notes that it replaces 4–6 sequential calls, making the efficiency rationale clear.

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