Arcgis Leecounty

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

Discloses default model (Workers AI Llama-3.3-70b), billing implications (BYO key for Anthropic), and return format (per-model score, confidence, signals, raw_response) beyond what annotations provide. 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?

Concise and front-loaded: first sentence states action and output. Each subsequent sentence adds key info (defaults, cost, return structure, use cases) without redundancy. No unnecessary words.

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

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

Covers all essential aspects: entity, models, optional key, context, and return format. Lacks explicit error handling or rate limit info, but given readOnly and idempotent hints, this is acceptable. Output schema not provided but return structure is described.

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 context: explains purpose of 'context' parameter for disambiguation, notes default models, and clarifies that _apiKey is passed directly to Anthropic. This adds value 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?

Description clearly states the action: probe LLMs for visibility scoring. It specifies verb+resource (probe LLMs for what they know) and differentiates from siblings like 'scan_competitor_ai_presence' by focusing on general entities and scoring (0-100).

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

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

Explicitly states use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring) and explains model selection and API key requirement. However, does not explicitly say when not to use or compare with similar 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. Description adds value by explaining the tool routes to 4,552 tools, returns structured data with stable pipeworx:// citation URIs, and that it 'works on every tier, one fast call'. 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 lengthy (multiple paragraphs) but justified by the tool's complexity and need to differentiate from siblings. Front-loaded with key message. Could be trimmed slightly, but each sentence serves a purpose (examples, usage guidance, alternatives).

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

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

Given high schema coverage, comprehensive annotations, and no output schema, the description fully covers the tool's function, usage context, and behavior. It sets expectations for alternative tools and provides concrete examples.

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

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

Schema coverage is 100%, so the schema already documents the parameter and its aliases. Description provides examples but does not add new semantic details beyond what the schema offers. 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?

Description clearly states it handles factual questions about current/historical data across many sources, provides citations, and distinguishes from siblings like ask_pipeworx_grounded and deep_research. Specific verb+resource: 'routes question to the right one of 4,552 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 says 'PREFER OVER WEB SEARCH', lists example queries, and gives clear guidance on when to step up to alternatives (ask_pipeworx_grounded for hallucination-resistant single answer, deep_research for broad multi-part, etc.). Specifies it's the default entry point.

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 readOnlyHint, openWorldHint, idempotentHint true and destructiveHint false. The description adds valuable behavioral details: the extra LLM call, the extraction process limited to tool results, and the full set of refusal reasons. No contradictions with annotations.

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

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

The description is well-structured with key information front-loaded, but it is relatively lengthy. Every sentence adds value, though some redundancy exists (e.g., listing all refusal reasons could be trimmed if output schema existed). Still, it maintains focus.

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

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

For a high-stakes answer tool with no output schema, the description thoroughly covers purpose, routing behavior, extraction process, return fields (answer, evidence, confidence, source, fetched_at, refusal_reason), and all possible refusal reasons. It also addresses the trade-off with the sibling tool, 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% with all parameters documented and aliases listed. The description mentions routing and argument filling but adds no additional meaning beyond the schema for individual parameters. Baseline of 3 is appropriate.

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

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

The description clearly states the tool's purpose as a 'Hallucination-resistant answer mode for high-stakes reads', specifying that it extracts answers using only tool results and returns structured outputs with evidence and refusal reasons. It distinguishes itself from the sibling tool 'ask_pipeworx' by noting the extra cost and extraction behavior.

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

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

Explicitly advises when to use: 'Use whenever an answer will be quoted, cited, or acted on, and the agent must not invent facts' with concrete examples (financial, legal, medical). It also provides a when-not-to-use recommendation: 'prefer ask_pipeworx for casual lookups' due to the extra LLM call.

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

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

Annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint) are present and consistent. The description adds extensive behavioral context: safety short-circuits on low-confidence resolution, closed/dead market handling, wide-spread indicators, resolution-rule risk, parent event extractor, news fallback fields. Far exceeds annotation coverage and adds critical decision-making information.

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

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

The description is very long but front-loaded with the core purpose. Detailed lists of classifiers, fan-out examples, response shapes, safety warnings, and resolution details are all valuable, but the sheer length could be overwhelming. A more structured format (e.g., bullet points) would improve readability without losing content.

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

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

No output schema is present, so the description must fully explain return values. It does so comprehensively: result.market fields, result.analysis with model probability and edge warnings, result.evidence keyed by source, market_match_confidence with alternatives and suggestions, parent_event extractor, news fields, and safety mechanisms. Everything an agent needs to interpret the response is documented.

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

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

Schema covers 100% of parameters, so description adds value by explaining market input formats, depth enum options ('quick' vs 'thorough'), and include_raw behavior. Provides concrete examples that clarify usage 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?

Clearly states it researches a Polymarket bet by pulling Pipeworx data, with specific input types (slug, URL, question text) and output (evidence packet + market-vs-model comparison). Usage examples are given but does not explicitly differentiate from siblings like polymarket_arbitrage or polymarket_edges, though the purpose is distinct enough.

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 use cases ('should I bet on X', 'what does the data say about Y', etc.) and provides detailed fan-out examples per classifier. However, no when-not-to-use or alternatives are mentioned, which would have improved the score.

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, and idempotentHint as true, and destructiveHint as false. The description adds valuable behavioral context: for companies, it pulls latest 10-K data and handles off-calendar fiscal years; for drugs, it pulls adverse-event counts, FDA approvals, and active trial counts. It also mentions results are sorted by primary metric and returns pipeworx citation URIs. This goes well beyond what annotations provide.

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

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

The description is compact yet comprehensive, starting with example queries and preference guidance, then detailing type-specific behavior, and ending with result format. Every sentence adds value without redundancy. It is well-structured and front-loaded with critical 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?

Given the lack of an output schema, the description does a good job of explaining what is returned: paired data and citation URIs, with results sorted by primary metric. However, it does not specify the exact fields or structure of the returned data for each entity type, which might require an agent to infer from context. This is a minor gap but overall the description is sufficiently complete for correct tool usage.

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

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

Schema coverage is 100% for both parameters. The description adds significant meaning: for the 'type' parameter, it explains the data sources behind each enum value; for the 'values' parameter, it specifies that companies use tickers/CIKs and drugs use names, with a range of 2-5. This enriches the schema descriptions and clarifies input 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 starts with multiple example queries that map directly to the tool's function, such as 'Compare X and Y' and 'which is bigger'. It clearly states that it performs side-by-side comparison of 2-5 companies or drugs in a single call, and distinguishes between type=company and type=drug by specifying the data sources (SEC EDGAR/XBRL for companies, FAERS/FDA for drugs). This specificity makes the purpose unambiguous and distinguishes it from sibling tools like entity_profile.

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

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

The description explicitly advises to 'ALWAYS PREFER over sequential single-pack lookups when comparing entities', providing strong guidance on when to use this tool over alternatives. It also states that it replaces 8-15 sequential lookups, reinforcing efficiency. While it does not explicitly state when not to use it, the context implies that single-entity queries should use entity_profile, which is listed as a sibling tool.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false. The description adds context: account requirement, paid plan details, expected response time (15-60s), return format (findings packet with verbatim evidence, confidence, source, gaps[]), and that it never invents answers. No contradictions with annotations. Slightly more detail than needed but valuable.

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

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

The description is detailed and front-loads the critical account/sign-in requirement. It is structured in a single paragraph but uses sentences clearly. It is not overly long given the tool's complexity, though it could be slightly more scannable with bullet points.

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 (parallel tool usage, many data sources, no output schema), the description covers input requirements, process, output format, limitations, and alternatives comprehensively. It addresses exactly what the agent needs to decide when to use this tool and what to expect.

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

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

Schema coverage is 100%, so the schema already documents both parameters. The description adds meaning: for 'depth', it explains the facet counts (quick=3, standard=5, thorough=8) and ties to paid plan for thorough. For 'question', it clarifies that broad/multi-part is fine. This goes beyond basic schema definitions.

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

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

The description clearly states 'grounded multi-source research across Pipeworx's 1160 STRUCTURED data sources' and distinguishes from sibling tools like ask_pipeworx by explicitly noting it decomposes questions into facets and uses 4,552 tools in parallel. The purpose is specific and unambiguous.

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

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

The description provides explicit guidance: when to use this tool (broad/multi-part structured questions), when to use alternatives (ask_pipeworx for single lookup, breaking news, or current news topics), and prerequisites (account required, free tier okay but 'thorough' depth needs paid plan). It also cautions against use for colloquial current-news topics.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds beyond this by detailing the return format: 'top-N most relevant tools with names, descriptions, and full input schemas (with curated examples) — each result is ready to call directly'. No contradictions.

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

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

The description is concise with two sentences covering purpose, examples, usage guidance, and return format. It is front-loaded with the core purpose. Slightly heavy on the list of domains but still efficient for the scope.

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

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

Given the tool's role as a meta-discovery tool with no output schema, the description adequately covers what it returns (names, descriptions, schemas), includes default/max limit, and explains the 'call first' strategy. Missing error/no-result handling but acceptable for a search tool.

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

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

Schema description coverage is 100% with clear descriptions for all parameters. The description adds value by explaining that the primary parameter 'query' accepts multiple aliases (task, q, description, search) and provides concrete examples, enhancing practical usability beyond the raw 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, with a specific verb 'discover' and a resource 'tools'. It distinguishes itself from sibling tools by explicitly stating 'Call this FIRST when you have many tools available', setting it apart from direct query tools like search_datasets.

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

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

The description provides clear context on when to use: 'when you need to browse, search, look up, or discover' and explicitly says to call it first. It lists many example domains. However, it lacks explicit guidance on when not to use it or what alternatives exist, though it's implied.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, etc.), the description details the tool's behavior: it fans out across multiple sources (SEC EDGAR, XBRL, USPTO, news, GLEIF) and returns specific fields (cik, recent_filings with URIs, fundamentals sorted by period_end, patents with sunset note, news via GDELT→GNews fallback, LEI). It also discloses a known failure mode (USPTO soft-fail May 2025).

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 dense paragraph that front-loads example queries and then provides detailed output information. It is efficient but could benefit from slight structuring (e.g., bullet points for the returned fields). Still, 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?

Given the complexity of the tool and no output schema, the description covers the main return fields (cik, filings, fundamentals sorted, patents with caveat, news, LEI) and their sources. However, it lacks specifics on the exact JSON structure or format of the output, which an agent might need to parse the result. It is fairly complete but not exhaustive.

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

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

The schema already describes both parameters with coverage 100%. The description adds value by reinforcing that 'type' is limited to 'company' and 'value' must be ticker or zero-padded CIK, and by explaining that names are not supported and directing users to resolve_entity. It clarifies the expected format of the CIK parameter.

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

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

The description uses multiple example queries ('Tell me about X', 'research Acme') to clearly indicate the tool's purpose: generating a holistic profile of a US public company. It explicitly distinguishes from siblings by recommending this tool over chaining multiple single-purpose lookups.

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

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

The description explicitly states when to prefer this tool ('ALWAYS PREFER over chaining single-pack SEC/XBRL/news lookups when the user asks for a holistic view') and provides input constraints ('Pass ticker or zero-padded CIK; names not supported – use resolve_entity first if you only have a name'). This gives clear guidance on when and how to use the tool.

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

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

Annotations already provide destructiveHint=true, so the destructive nature is known. The description adds behavioral context by explaining why to use it (clearing stale or sensitive data) and pairing alternatives, which enhances transparency beyond the annotations.

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

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

Two sentences, no wasted words. Purpose is front-loaded, usage guidance follows concisely. Every sentence serves a purpose.

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

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

For a simple tool with one parameter, no output schema, and full annotation coverage, the description covers all necessary aspects: purpose, when to use, and related tools. It is complete and sufficient.

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

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

The single parameter 'key' has 100% schema description coverage, so the schema already explains it. The description doesn't add any additional meaning beyond 'Memory key to delete' which is identical to the schema description. 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 states 'Delete a previously stored memory by key' with a specific verb and resource. It distinguishes itself from siblings like 'remember' and 'recall' by mentioning pairing with them, and the title 'Forget' matches the action clearly.

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 the tool ('when context is stale, the task is done, or you want to clear sensitive data') and mentions sibling tools ('Pair with remember and recall') for context. This provides clear guidance and differentiation.

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

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

Annotations already indicate the tool is safe (readOnlyHint, idempotentHint, destructiveHint false). The description adds behavioral detail: fetching a page, extracting specific elements, and outputting markdown. It does not cover error handling or rate limits, but annotations satisfy the safety burden.

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: two sentences plus a bullet list of use cases. It front-loads the main action and purpose. No redundancy or fluff.

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

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

Given no output schema, the description mentions the output format ('single text blob ready to drop at site-root/llms.txt'). It does not cover error scenarios or authentication, but annotations imply no auth needed. The tool has only two simple parameters, making the description fairly complete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description does not add new meaning beyond the schema, e.g., for max_links the schema is explicit. Description's mention of 'extracts title/description/key links' connects to url but does not enhance parameter understanding.

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

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

The description clearly specifies the verb 'generate', the resource 'llms.txt file', and the actions 'fetches the page, extracts title/description/key links, and emits the standard llms.txt markdown format'. It distinguishes from sibling tools by focusing on file creation rather than checking visibility or scanning presence.

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

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

The description provides clear use cases: 'getting a client's site indexed by AI, drafting llms.txt for your own project, or auditing how an AI crawler would see a competitor'. However, it does not explicitly state when not to use the tool or list alternatives among siblings.

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

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

Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds value by specifying the exact schema elements returned (fields, geometry type, record count, capabilities). No contradictions.

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

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

The description is a single, front-loaded sentence that efficiently conveys the tool's purpose and output without unnecessary words.

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

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

Given the simple input (one URL) and no output schema, the description sufficiently lists what the tool returns. Annotations cover behavioral aspects. Minor gap: could mention if any permissions are required, but not critical.

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

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

Schema description coverage is 100% for the single url parameter, which is well-described in the schema. The description mentions 'by url' but adds no additional semantic meaning beyond what the schema provides.

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

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

The description clearly states the tool gets an ArcGIS Feature/Map Service layer's schema by URL, listing specific details (fields, geometry type, record count, capabilities). This distinguishes it from sibling tools like query_layer, which queries data.

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

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

While the description implies usage for retrieving layer schema, it does not explicitly state when to use this tool versus alternatives or when not to use it. Context from sibling names provides some differentiation, but explicit guidance is missing.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, indicating a safe read operation. The description adds the specific fields returned but does not disclose additional behavioral traits beyond what annotations cover. No contradictions.

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

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

The description is two concise sentences with no fluff. The purpose and usage are immediately clear, and 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?

Given the simple structure (1 optional param, no output schema but fields listed) and excellent annotations, the description fully covers what the agent needs to know to use the tool correctly.

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

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

Schema coverage is 100% and the schema already provides a description for the single parameter (include_inactive). The tool description does not add further meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description clearly states the action ('List'), the resource ('subscriptions'), and specifies the scope ('the caller's active subscriptions'). It also enumerates the fields returned, making the purpose unambiguous.

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

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

The description provides explicit guidance on when to use the tool: 'to review what you're monitoring before adding more or to find an id to cancel.' It does not explicitly mention alternatives or when not to use it, but the context from sibling tools (subscribe, unsubscribe) 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?

Discloses rate limiting (5 per identifier per day), that it's free and doesn't count against quota, and implies it's non-destructive. Annotations are neutral; description adds valuable 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?

Description is concise with 5 sentences, front-loaded with purpose, all information relevant and no fluff.

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

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

Given the tool's simplicity (3 params, 2 required, no output schema), the description covers purpose, usage, formatting, and constraints completely.

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

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

Schema coverage is 100%, but description adds deeper meaning: explains each enum value for type, advises specificity and character limit for message, and describes context fields' purpose.

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 'Tell' and resource 'Pipeworx team', and distinguishes between bug, feature/data_gap, praise, and other, making it unique among siblings which include ask and 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?

Explicitly specifies when to use: for bugs, missing features, data gaps, or praise. Also provides 'don't' rules (avoid pasting user prompts) and advises to describe in terms of tools/packs.

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

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

Annotations already indicate read-only, idempotent, safe behavior. The description adds caching details (5min-1h), data source (CF analytics-engine), and privacy (no PII), providing extra 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) with front-loaded main output, then use cases, then technical details. Every sentence adds value; no fluff.

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

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

For a simple read-only tool with one parameter and no output schema, the description explains output structure (top tools/packs, total calls), data source, and caching. Missing exact result format but acceptable given simplicity.

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

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

The input schema covers the single parameter fully with enum and description. The tool description adds context: shorter windows show immediate trends, longer windows show steady-state demand, enhancing semantic understanding.

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

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

The description clearly states the tool returns top tools, packs, and call volume over a window, with a specific verb 'Returns' and resource 'Pipeworx trending'. It distinguishes from siblings by focusing on aggregated trend data rather than direct queries or discovery.

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

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

The description lists three explicit use cases: discovering hot data sources, confirming canonical tools, and aligning with agent needs. It implies when to use (trending insight) and contrasts with other tools, though it lacks explicit 'when not to use' guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, etc. The description adds extensive behavioral context: internal checks (monotonicity, partition sum, placeholders filter), response structure, fill check pricing against live CLOB depth, and warnings (e.g., 'do not trade it' when realizable_edge_pp ≤ 0). 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 lengthy but each sentence adds value. It is well-structured: overall purpose, mode details, internal checks, response format, fill check, and sibling hint. Could be slightly more concise, but the complexity justifies the detail.

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

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

No output schema, so description compensates by detailing the return structure (opportunities[], partition_check). Covers fill check behavior and mentions filters. Could mention error handling for invalid slugs or rate limits, but overall very complete for a complex tool.

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

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

Schema coverage is 100% with descriptions for both parameters, but the description significantly adds meaning: explains the difference between modes, gives example values ('fed-decision-may-2026'), notes default behavior with no args, and describes the cross-event similarity filter. This goes well 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 finds arbitrage opportunities via 'monotonicity violations + partition-sum checks' and distinguishes two modes (event/topic) with a default. It differentiates from sibling tools like polymarket_edges and polymarket_fill_risk by specifying its unique arbitrage focus.

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 guidance for each mode: 'use this if you know the specific Polymarket event' for event, 'use this if you want to scan related events' for topic, and recommends event mode. It also mentions sibling polymarket_fill_risk for custom sizing, though does not fully exclude all 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 indicate readOnly, openWorld, idempotent, and non-destructive. The description adds substantial behavioral context: caching (1h KV keyed on knobs), response structure (by_segment, fed_candidates, _diagnostics), model details (lognormal barrier, GDELT ratio, partition_overround with placeholder-filter), edge calculation (net of slippage, Kelly sizing), and 24h-move warnings. No contradictions.

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

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

The description is lengthy but well-structured with clear segments (model families, response structure, knobs, diagnostics). Information is front-loaded with purpose and models, then detailed parameters. Some formula details could be pruned for a tool-level description, but the structure is logical and 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?

Given no output schema, the description comprehensively explains the response format: top-level segments, fields per opportunity (edge_pp_net, kelly_fraction, liquidity, spread, volume, 24h-warning), and diagnostics for empty segments. It covers edge cases (Fed bets) and caching. The tool is fully specified for agent 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%, but the description adds rich semantics for each of the 9 parameters. For example, min_kelly: 'Skip opportunities that are too small to bet sensibly'; min_liquidity: 'Set to 5000 to drop thin-book opportunities'; slippage_pp: explains Polymarket fees and recommends adjustments. This adds significant practical 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 states the tool's purpose explicitly: 'Scan top Polymarket markets and return opportunities where Pipeworx data disagrees with market price.' It distinguishes from siblings by detailing the three model families (MODEL_DRIVEN, STRUCTURAL_ARBITRAGE, CONCENTRATED_LONGSHOT), positioning it as a discovery tool for agents, unlike generic arbitrage or edge trackers.

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 frames usage as 'what should I bet on today' and provides extensive guidance on configuration via knobs (e.g., min_liquidity, max_spread_pp). It explains when segments are empty (diagnostics) and caching behavior. However, it does not explicitly state when to use alternatives like polymarket_arbitrage or polymarket_edge_tracker.

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 readOnly, openWorld, idempotent, and non-destructive. The description adds rich behavioral details: it reads from daily snapshots (cache-miss gaps), computes trend and decay on |edge_pp_net|, includes expired opportunities with lifespan, and explains that snapshots are written only on cache-miss. No contradictions.

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

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

The description is informative and well-structured, starting with the core question, then detailing response fields, and ending with limits. It is verbose but each sentence adds value. Could be slightly more concise 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 fully explains the response structure (tracked, expired, snapshot_dates), limits, and edge cases (gaps, TTL). It is complete for the tool's complexity and 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%, so baseline is 3. The description adds context like 'lookback in days' and 'default 1wk' but essentially restates what the schema already says. No new critical parameter meaning beyond schema.

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

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

The description answers the specific question 'how long has this edge existed and is it shrinking?' and clearly defines the tool's function: edge persistence and decay telemetry from daily snapshots. It distinguishes from sibling tools like polymarket_edges by focusing on temporal analysis.

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

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

The description provides context on when to use the tool (e.g., comparing a fresh edge vs. a 3-week-old edge), implying its value for trade timing. It mentions limits such as 60-day TTL, but does not explicitly state when not to use it or directly reference 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?

The description adds significant behavioral context beyond annotations. It explains that the tool walks the ladder, returns a verdict (clean, degraded, cannot_fill), and details the risks of partial fills and 'forced directional risk'. This aligns with and complements the readOnlyHint, openWorldHint, and idempotentHint annotations.

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

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

The description is well-structured with clear sections for single-market and basket modes, using uppercase for key terms. While it is relatively long, every sentence provides necessary information for a complex tool. Minor redundancy could be trimmed, but it remains efficient for the 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?

Despite having no output schema, the description enumerates all returned fields for both modes (e.g., top_of_book, vwap_fill_price, slippage_pp, verdict for single-market; theoretical_sum, realizable_sum, capture_ratio, profit_usd, thin_legs for basket). It also explains the risks and edge cases, making the tool's behavior fully comprehensible.

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

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

The input schema has 100% description coverage, and the tool description adds further context for parameters. It explains the default values and interpretation for size_usd (default 1000, max spend on buys/target proceeds on sells for single-market; settlement notional for basket) and side (default buy_yes for single-market, auto for basket based on partition sum).

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 realizable-vs-theoretical edge check against live CLOB order-book depth. It distinguishes between single-market and basket modes, and explicitly differentiates from sibling tools like polymarket_arbitrage and polymarket_edges by specifying when to use this tool before acting on their signals.

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

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

The description provides explicit guidance on when to use the tool: before acting on agrobirtrage signals or edges above $500. It also explains when not to use it, such as when theoretical overround is not capturable on thin books, and warns about the risks of partial basket fills converting an arb into an unhedged directional position.

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 behavioral traits beyond annotations: explains compatibility_warning scenarios, temporal_alignment, skipped_cross_type/subtype, and that spreads require equivalent bet shapes. No contradiction with annotations.

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

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

Well-structured and front-loaded with key purpose, but somewhat lengthy. Every sentence adds value, but could be more concise without losing 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?

Without output schema, description fully explains response fields (prices, spreads, safety fields) and provides sufficient context for agent to interpret results.

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

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

Schema coverage is 100% and descriptions are already present, but the description adds context on how parameters interact (e.g., override behavior, pre-mapped vs explicit). 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 the tool computes cross-venue spread between Kalshi and Polymarket. Distinguishes from siblings like polymarket_arbitrage by explicitly mentioning both venues.

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, including conditions for compatibility_warning and warning that most pre-mapped topics are not tradeable. Also explains the two modes.

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

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

Annotations already declare readOnly and idempotent. Description adds that it returns attribute rows and geometry, which is useful beyond annotations. No contradiction.

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

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

Two well-constructed sentences and a tip. Front-loaded with purpose. Every sentence earns its place; no redundancy.

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

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

Covers return type (attributes and geometry) and core query capabilities. No output schema, but description adequately describes expected output for a query tool.

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

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

Schema coverage is 100%, baseline 3. Description adds semantics by explaining SQL-like syntax, comma-separated fields, and default values (e.g., where='1=1'). Adds examples 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 the tool queries an ArcGIS Feature/Map Service layer by URL, specifying the source from search_datasets. Differentiates from siblings like layer_info (metadata) and search_datasets (finding layers).

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

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

Provides explicit examples of query parameters (SQL-like where, out_fields, etc.) and a tip for sampling. Does not explicitly exclude scenarios, but the context of sibling tools provides differentiation.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. Description adds scoping details (by identifier) and pairing guidance, which are beyond what annotations provide. 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?

Four sentences, front-loaded with core purpose, no fluff. Every sentence adds value: retrieval modes, use case, scoping, companion tools.

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

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

For a read-only tool with one optional parameter and no output schema, the description fully covers what the agent needs: what it does, how to call (with/without key), scoping, and relationship 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?

Schema coverage is 100% and the schema description already explains the parameter (omit to list all keys). Description restates this but does not add new semantic nuance. 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?

Description clearly states two modes: retrieve a specific value or list all keys, with explicit reference to sibling tools (remember, forget). The verb 'retrieve' and 'list' are specific and unambiguous.

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

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

Provides clear context for when to use: to look up previously stored context without re-deriving. Mentions pairing with remember/forget. Missing explicit when-not-to-use or alternatives, but the usage is well-understood for a simple retrieval tool.

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

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

The description contradicts the readOnlyHint annotation by allowing state changes via mark_read:true, which flags events as read and affects future calls. This is a clear contradiction, as readOnlyHint implies no writes.

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

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

The description is concise: three sentences cover purpose, return structure, filtering, and a special behavior. No fluff; every sentence provides value.

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

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

Given no output schema, the description explains return structure (source, citation_uri, raw payload) and notes polling suitability and an alternative endpoint. It lacks details on pagination or error handling, but annotations cover safety 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%, so each parameter is described. The description adds extra semantics for mark_read, explaining its effect on subsequent calls, and mentions limit and since in context. This goes beyond the schema's short descriptions.

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

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

The description clearly states it pulls fired events from the subscription feed, specifies the return fields (source, citation_uri, raw payload), and lists filtering options. It distinguishes from siblings like list_subscriptions and note_tools by focusing on recent alerts and marking read behavior.

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 usage context: it is suitable for polling ('Polls work fine'), filtering by type and time, and optionally marking events read. It mentions an alternative REST endpoint, but does not explicitly state when not to use it or compare to 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=true (safe read) and idempotentHint=true. The description adds rich behavioral context: parallel fan-out to multiple sources, fallback logic (GDELT→GNews on rate limits), USPTO soft-fail status, and return structure (changes[] with source grouping and citation URIs). No contradictions.

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

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

The description is a single, dense paragraph that front-loads the most important usage examples. Every sentence earns its place—no fluff, no redundancy. Despite covering many data sources and parameters, it remains efficient and readable.

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 explicitly states the return structure (grouped changes, total count, citation URIs). It covers error handling (falls back to GNews, soft-fail for USPTO) and parameter options comprehensively. For a tool with 3 required parameters and multiple data sources, this is very complete.

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

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

Schema coverage is 100%, but the description adds significant practical value: explains type enum only supports 'company', gives multiple examples for since (ISO date and relative shorthand), recommends '30d' or '1m', and clarifies value can be ticker or CIK. This goes well beyond the schema descriptions.

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

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

The description opens with clear natural language examples ('What's new with X', 'latest on Y') and explicitly states it's a change feed for a company in a time window. It lists specific sources (SEC EDGAR, GDELT→GNews, USPTO) and distinguishes itself from entity_profile by calling out when to use the alternative.

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

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

The description provides explicit 'when-to-use' examples (e.g., 'what happened to Z this week/month/quarter') and an explicit 'when-not-to-use' by directing users to entity_profile for static profiles. It also gives practical advice like using '30d' or '1m' for typical monitoring.

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

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

Adds context beyond annotations: scoped to user identifier, persistent vs 24-hour retention, and idempotent behavior is implicitly supported (setting same key again is fine). 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?

Five sentences, front-loaded with purpose, efficient and 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 simple params and no output schema, the description covers storage scope, persistence, and usage pattern comprehensively.

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

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

Schema covers both parameters fully; description adds usage examples (e.g., key naming conventions) that help the agent use parameters correctly without repeating schema details.

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 saves data for reuse, provides concrete examples (ticker, address, preference), and explicitly distinguishes it from siblings recall and forget.

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

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

It tells when to use ('when you discover something worth carrying forward'), explains session persistence, and directs to pair 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?

Annotations already confirm read-only, idempotent behavior; the description adds that each call cascades through multiple endpoints internally and details return fields for each type, which is useful 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 efficiently structured, opening with natural language examples, then stating the core use, then detailing supported types. 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?

Given no output schema, the description covers return values and citation URIs for both types. Minor gap: does not address error cases or ambiguous input handling.

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

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

Schema coverage is 100%, and the description adds examples, auto-disambiguation for company, and acceptable input formats for drug, going well beyond the schema definitions.

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

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

The description clearly states the tool resolves names to canonical identifiers, provides example queries, and distinguishes itself from siblings by stating 'Use FIRST whenever you have a name but need an ID.'

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

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

The description gives clear context for when to use ('whenever you have a name but need an ID') and contrasts with manual lookups, but does not explicitly exclude cases or mention alternative 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 provide safety profile (readOnly, idempotent, non-destructive). Description adds: internal orchestration calling ai_visibility_check, ranking behavior, output format (score, confidence, signal density per entity). 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?

Three sentences: purpose, mechanism, use case and output. Every sentence adds value without redundancy. No fluff.

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

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

Despite no output schema, description explains ranked list content. All parameters are described. Complexity of orchestration is addressed. Sibling context shows this is a comparative version of ai_visibility_check. Completely adequate.

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

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

Schema coverage is 100% but description adds crucial semantics: 'First entry treated as subject for narrative', 'Omit models for just workers-ai', and explains context as shared disambiguation. These go 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?

Description clearly states verb 'compare', resource 'AI visibility across multiple entities', and specific actions 'probes', 'ranks by score', 'surfaces which is most/least recognized'. Distinguishes from sibling ai_visibility_check which is single-entity.

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

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

Explicitly states usefulness for 'competitive AI-marketing audits' with a concrete example question. Does not explicitly list when not to use, but the contrast with ai_visibility_check is implicit. Lacks explicit alternative naming.

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?

Explains fan-out to two services, potential timeout on bundlephobia (5-30s), graceful degradation via 'sources_failed', and enumerates return fields. This adds significant 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?

Description is thorough but slightly verbose; it is well-structured with purpose first, then usage, then behavioral details. Still earns its length.

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

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

Despite no output schema, description fully details return structure, error handling, and limitations. Covers all necessary context for a single composite check.

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 descriptions in schema (100% coverage). Description adds acceptance of scoped packages and defaulting version to latest, adding value beyond schema.

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

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

The description clearly states it checks npm package safety, popularity, and size using deps.dev and bundlephobia. It distinguishes itself from other ecosystems and potential siblings by specifying 'NPM ecosystem only in v1.'

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 tells when to use: 'Use whenever an agent asks 'is X safe / popular / small' or 'what does adding lodash cost me'.' Also provides alternatives for other ecosystems.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, covering safety. Description adds return fields and workflow details, but no additional behavioral traits beyond what annotations imply.

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 sentence states purpose and scope, second sentence details output and follow-up. 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 3 parameters with full schema coverage, annotations, and no output schema, the description sufficiently explains return values and usage pattern. No gaps.

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

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

Schema coverage is 100% so baseline is 3. Description mentions searching by keyword, which aligns with the 'query' parameter, but adds no extra meaning beyond the schema's descriptions for limit and org_id.

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

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

Clear verb 'Search' and specific resource 'Lee County GIS open geospatial datasets' with examples (parcels, addresses, zoning & public works). Distinguishes from siblings by directing the output url to query_layer/layer_info.

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

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

States to search by keyword and explicitly tells the user to pass the returned url to query_layer/layer_info, providing clear context on when to use and what to do next. Does not explicitly exclude alternatives but is sufficient.

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

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

Beyond annotations (readOnlyHint, idempotentHint, etc.), the description adds rich behavioral details: 'BGE-base-en embeddings + cosine over 500-char overlapping windows; cap is 200K chars (longer inputs are truncated and flagged)'. It also mentions that every passage carries an offset for verification. No contradiction with annotations.

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

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

The description is well-structured and front-loaded with purpose. It is slightly long but information-dense, with each sentence adding value (use case, benefit, pairing, technical details). Minor conciseness improvements could be made, but overall effective.

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

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

The description covers usage, behavior, and pairing, but lacks a detailed description of the return format. It mentions 'top-N passages with character offsets and similarity scores' but does not specify the structure (e.g., array of objects with fields). With no output schema, this is a noticeable gap for an otherwise thorough 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 description coverage is 100%, but the description adds significant meaning: for 'text', it specifies 'max ~200K chars'; for 'query', it gives examples like 'supply-chain risk'; for 'limit', it states range '1-20, default 5'. This goes beyond the schema's basic descriptions.

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

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

The description clearly states the tool's purpose: semantic search inside a fetched record. It specifies the verb 'search', the resource 'a fetched record', and provides examples like 'SEC 10-K body, an article, a long tool result'. It also distinguishes from siblings by mentioning pairing with ask_pipeworx_grounded, showing awareness of alternatives.

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

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

The description explicitly says when to use: 'when the record is too big to cram into the prompt'. It also provides a clear alternative: 'Pairs with ask_pipeworx_grounded: fetch with the gateway, ground over the relevant passages instead of the whole document.' It lacks explicit when-not-to-use statements but provides strong context.

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

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

Annotations indicate non-readOnly, idempotent, non-destructive. The description adds critical behavioral details: OAuth requirement, channel specifics (feed always on, email/SMS/options, SMS cap, webhook auto-disable), and that subscription id is returned once. No contradictions.

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

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

The description is dense and well-organized (prerequisites, types, delivery options, constraints), but relatively long. Every sentence adds value; minor improvement could be slightly tighter phrasing.

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

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

Given the tool's complexity (multiple event types, delivery channels, constraints) and absence of an output schema, the description covers all necessary context: authentication, type details, parameter formats, delivery behaviors, and limitations (SMS cap, webhook auto-disable).

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

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

Schema coverage is 100%, but the description provides rich additional meaning: for 'type' it gives examples and matching criteria (e.g., 'items:["5.02"] = officer change'), for 'params' it offers type-specific filter structures, and for 'delivery' it explains constraints and webhook signing. This significantly aids agent understanding.

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

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

The description clearly states the verb ('Create') and resource ('proactive monitoring subscription to a live-data event stream'), and mentions the return value. It distinguishes this tool from siblings like list_subscriptions and unsubscribe by focusing on creation.

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 prerequisites (Pipeworx OAuth account) and provides context for use cases via type examples. It lacks explicit when-not-to-use or alternative tool references, but the context is strong enough.

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

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

The annotations already declare readOnlyHint, openWorldHint, and idempotentHint, so the description's main value is in explaining that it returns categorized examples and that it draws from the live catalog. This adds useful context 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 somewhat long but well-structured, starting with user queries to capture attention, then explaining functionality and usage. Each sentence adds value, and the key information is front-loaded. It could be slightly more concise, but it's not overly verbose.

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

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

Given no output schema, the description explains what the tool returns (category-bucketed example questions with tool and argument shape) and notes it is dynamic (live catalog). It covers the primary use case of onboarding. It might be improved by hinting that it doesn't answer questions directly, but the purpose is clear.

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

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

Schema coverage is 100% with a single optional 'topic' parameter. The description adds meaning by listing example focus areas (finance, pharma, etc.) and explaining that omitting it gives a cross-category spread, while providing it focuses the results. This is more informative than the schema alone.

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

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

The description clearly states that the tool returns category-bucketed example questions with exact tool and argument shape, serving as the onboarding entry point. It uses specific verbs like 'returns' and 'use this first,' and distinguishes itself from sibling tools like 'discover_tools' by focusing on suggesting questions rather than listing tools.

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

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

The description explicitly advises to use this tool 'FIRST when you do not yet know what Pipeworx can do' and to learn how to call meta-tools. It also explains when to pass a topic vs. no arguments. However, it could be more explicit about when not to use it, such as when you already have a specific task in mind.

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 behavioral details beyond annotations: ownership enforcement, deactivation not deletion, and preservation of historical events via recent_alerts. Aligns with annotations (destructiveHint=false).

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

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

Three short sentences, each adding essential info: action, ownership, and effect. No wasted words; front-loaded with the core purpose.

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

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

Given low complexity (1 param, no output schema), the description fully explains the tool: what it does, constraints, and link to related tool (recent_alerts). Complete for effective use.

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

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

Schema coverage is 100%, so baseline is 3. Description does not add new parameter info beyond what the schema provides, but implicitly references the id 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?

Clearly states the action (cancel), resource (subscription), and identifier (by id). Distinguishes from sibling tools like subscribe and delete by mentioning ownership enforcement and deactivation rather than deletion.

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

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

Provides clear context: cancel a subscription, ownership enforced, and deactivation effect. Lacks explicit when-not-to-use or alternative tools, but ties to recent_alerts for historical events.

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 safe, non-destructive read operation. Description adds that verification uses SEC EDGAR + XBRL, returns structured verdict with citation, and replaces multiple calls. 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 front-loaded with example triggers, then usage, then scope and returns. Efficient use of sentences, though the list of synonyms could be slightly tightened.

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 single-parameter tool with no output schema, the description fully covers purpose, scope (US public companies), usage, and return values. No gaps remain.

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

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

Schema coverage is 100% with a description for the single 'claim' parameter. Description adds examples and explains return structure (verdict, actual value, citation), providing 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 explicitly defines the tool as a claim verifier using example queries like 'Is it true that…' and specifies it handles company-financial claims. It distinguishes from sibling tools by noting it replaces multiple sequential calls.

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

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

Clearly states to use when checking factual correctness of a user's statement. Implicitly excludes non-financial claims by specifying scope, but does not explicitly name alternative tools for other claim types.

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