Shakespeare Insult

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

The description discloses key behavioral traits beyond annotations: probing multiple LLMs, default model (Workers AI), optional Anthropic usage with BYO key, and return format (per-model {score, confidence, signals, raw_response} + combined view). No contradictions with annotations (readOnly, idempotent, non-destructive).

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

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

The description is a single, well-structured paragraph that front-loads the purpose, then details model options, return structure, and use cases. Every sentence adds value, no filler.

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

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

Given 4 parameters, no output schema, and the presence of a similar sibling (scan_competitor_ai_presence), the description is nearly complete. It covers purpose, inputs, return format, and use cases. Slight omission: why choose this over the sibling, but overall adequate.

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

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

With 100% schema description coverage, parameters are already well-documented. The description adds value by explaining the default model, meaning of _apiKey (BYO key, direct billing), and how context disambiguates. It goes beyond simple schema docs.

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

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

The description clearly states the verb 'Probe' and resource 'LLMs for what they know about... score visibility'. It explicitly lists use cases (AI-marketing audits, pre-launch brand checks, competitive monitoring) and distinguishes from siblings like 'scan_competitor_ai_presence' by focusing on per-model scoring and combined view.

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 when-to-use guidance through use cases and explains default vs. optional model selection (_apiKey). However, it does not explicitly state when not to use or differentiate from similar tools like 'scan_competitor_ai_presence', which would strengthen the guidelines.

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

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

Discloses that Pipeworx picks the right tool and fills arguments, abstracting away tool browsing. With no annotations, the description fully covers behavioral traits like automated tool selection and result return.

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 three-sentence description plus examples. Front-loaded with purpose. Could be slightly more structured (e.g., list examples), but no waste.

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

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

Given single parameter, no output schema, and no annotations, the description is complete for its simplicity. It explains how the tool works and what to expect. Could add more about limitations, but not necessary for a straightforward Q&A tool.

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

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

The schema covers 100% with a clear description. The description adds examples and context beyond schema, like 'plain English' and 'no need to browse tools', enhancing meaning for the single 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 it answers plain English questions by selecting the best data source. Specific verb 'ask' and resource 'Pipeworx' with clear examples distinguishing it from sibling tools like discover_tools or shakespeare_insult_generate.

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 to describe what you need in natural language, with examples. However, no guidance on when not to use it (e.g., for non-factual questions or specific tool needs), but context signals and sibling names imply it's the general Q&A tool.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true. The description adds valuable behavioral context: it resolves markets, classifies bets (enum given), fans out to specific packs (examples provided), and returns an evidence packet plus market-vs-model comparison. It does not mention any destructive actions, consistent with annotations. There is 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 a single paragraph that is relatively long and includes some marketing language ('This is the core demo product... convert better'). It is front-loaded with the core action, but the extra sentence adds little informational value. While concise overall, there is some verbosity that could be trimmed.

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

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

Given the tool's complexity (classification, fan-out, comparison) and the absence of an output schema, the description provides adequate context: input flexibility, classification categories, fan-out logic, and output components. It does not detail the exact structure of the evidence packet or comparison, but the description is sufficient for an agent to understand the tool's purpose and expected 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?

The input schema has 100% description coverage for both parameters. The main description repeats some of this information (e.g., depth options, market input formats) but adds examples (slugs, URLs) that enhance clarity. However, it does not provide significant new meaning beyond what the schema already 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?

The description clearly states the action (Research) and the resource (Polymarket bet). It specifies that it pulls Pipeworx data, resolves the market, classifies the bet, fans out to relevant packs, and returns an evidence packet with comparison. It also distinguishes this tool from siblings by focusing on integrated Polymarket research, contrasting with general tools like ask_pipeworx.

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

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

The description explicitly lists use cases: 'should I bet on X?', 'what does the data say about this Polymarket market?', or 'is there edge in this bet?'. It implies that this tool is the integrated approach versus discovering packs individually. However, it does not provide explicit when-not-to-use scenarios, such as when only a single data pack is needed.

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

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

No annotations provided. The description adds value by detailing returned data per entity type and mentioning pipeworx:// URIs, but omits auth needs, rate limits, or error behavior.

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

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

Two sentences densely packed with purpose, usage, and output info, front-loaded with key action. No filler.

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

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

No output schema, but description specifies exact metrics per entity type (revenue, net income, etc.). Lacks output format details but adequate for typical 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%; description does not add parameter-specific meaning beyond schema. It contextualizes values (tickers/CIKs vs drug names) but not enough to raise baseline from 3.

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 'compare' and the resource '2–5 entities' with specifics for company and drug types. It distinguishes itself by noting it replaces 8–15 sequential agent calls, making its purpose and advantage explicit.

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

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

The description implies efficient multi-entity comparison, contrasting with sequential calls. However, it does not explicitly state when not to use it or compare with siblings like resolve_entity, leaving some guidance implicit.

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?

No annotations are provided, so the description carries full burden. It states the tool 'returns the most relevant tools with names and descriptions' and mentions default limit and max limit. However, it doesn't disclose whether the tool is read-only, any side effects, rate limits, or how relevance is determined. For a search tool, the description is adequate but could be more explicit about non-destructive behavior.

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

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

The description is two sentences long, front-loads the purpose, and each sentence serves a clear function: first explains what it does, second gives usage guidance. No unnecessary words.

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

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

Given that there is no output schema, the description should mention what the return value contains. It does: 'Returns the most relevant tools with names and descriptions.' This is sufficient. The tool is simple (2 params, no enums, no nested objects), so the description covers the essentials. Could mention that it returns a list, 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 coverage is 100% (both parameters have descriptions). The description adds value by explaining the query parameter format with examples (e.g., 'analyze housing market trends') and clarifying that limit has a default (20) and max (50). However, the schema already provides parameter names and descriptions, so the description's additional context is moderate.

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: 'Search the Pipeworx tool catalog by describing what you need.' It specifies the verb 'search', the resource 'tool catalog', and the action 'returns the most relevant tools with names and descriptions.' This distinguishes it from siblings like 'ask_pipeworx' (which likely answers questions) and other memory 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: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This provides clear when-to-use guidance, especially given the large number of tools (500+). It also implies not to call this when you already know the tool, or when fewer tools are available.

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

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

The description discloses the bundled data sources and the output format (pipeworx:// citation URIs). It notes that federal contracts are excluded due to speed concerns. However, it does not explicitly mention read-only nature, error handling, or rate limits, though the lack of annotations raises the bar slightly.

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 (5 sentences), front-loads the overall purpose, and provides detailed breakdown of data sources and usage notes without extraneous 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 tool's complexity (bundling multiple data sources) and simple schema, the description covers all needed information: what data is included, how to identify entities, output format, and when to use alternatives. No output schema exists, but the description suffices.

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?

With 100% schema coverage, the baseline is 3. The description adds value by explaining the `value` parameter accepts ticker or CIK and notes that names are not supported, which is beyond the schema description. It also interprets the `type` enum.

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 retrieves a full entity profile across multiple Pipeworx packs, listing specific data sources (SEC filings, XBRL, patents, news, LEI). It distinguishes from siblings by noting it replaces multiple sequential calls and explicitly directs to another tool for federal contracts.

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 and when-not-to-use guidance: it replaces 10-15 sequential calls, and for federal contracts, it directs to use `usa_recipient_profile` directly. It also hints at using `resolve_entity` if only a name is available, clarifying prerequisites.

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?

No annotations are provided, so the description carries the full burden. It correctly states the delete operation but does not disclose behavioral traits like whether deletion is permanent, if confirmation is required, or effects on other memories. Basic transparency, but not thorough.

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 sentence, front-loading the action and object. No wasted words; every part is essential.

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

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

Given a simple tool with 1 required parameter, no output schema, and no nested objects, the description is nearly complete. It lacks only behavioral nuance (e.g., irreversibility) which would make it perfect.

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 has 100% coverage and already describes the key parameter. The description adds the context that the key identifies the memory to delete, which aligns with the schema. No additional meaning beyond the schema is necessary, so a score of 4 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 ('Delete'), the resource ('stored memory'), and the identifier ('by key'). It is specific and distinguishes itself from siblings like 'recall' and 'remember' which handle retrieval and storage.

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

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

The description implies when to use this tool (when you need to delete a memory by key) but provides no guidance on when not to use it or alternatives. Since there are related tools for memory operations, explicit guidance would be helpful.

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 explains the process: fetches the page, extracts title/description/key links, and emits standard llms.txt markdown. It also notes the output is a text blob for site-root/llms.txt, adding context.

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

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

Two sentences with no wasted words. Front-loaded with the primary action and output, efficiently covering purpose, process, and use cases.

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

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

For a simple tool with 2 parameters and no output schema, the description fully covers input, process, output, and usage scenarios. No gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description mentions the url parameter indirectly but relies on schema for details. It adds no extra semantic meaning beyond schema, meeting the baseline.

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

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

The description explicitly states the tool generates a production-ready llms.txt file for any URL, specifying the purpose for AI crawlers. It clearly differentiates from siblings by focusing on a specific output format.

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

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

The description lists concrete use cases (getting a client's site indexed, drafting for own project, auditing competitors) but does not explicitly mention when not to use or provide alternatives, which is acceptable given no similar sibling.

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?

No annotations are provided, so the description bears the full burden. It discloses the rate limit and the constraint about excluding user prompts. No contradictory or hidden behaviors are implied.

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

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

The description is extremely concise: two sentences that clearly convey purpose, usage, and constraints without any filler. Perfectly front-loaded.

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

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

Given the tool's simplicity (send feedback with no output), the description covers all necessary aspects: purpose, when to use, what to avoid, and rate limits. The optional context parameter is sufficiently explained in the schema.

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

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

Schema description coverage is 100%, so parameters are already well-documented in the schema. The description adds value by reinforcing specificity in messages and the rate limit context, which is not in 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 'Send feedback to the Pipeworx team' and enumerates specific use cases (bug reports, feature requests, missing data, praise). This distinguishes it from sibling tools like ask_pipeworx (querying) or compare_entities (comparison).

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

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

Explicitly tells when to use (for feedback types) and what not to include (end-user's prompt verbatim). Also mentions a rate limit of 5 messages per identifier per day, providing clear operational guidance.

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

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

The description adds significant behavioral context beyond the annotations: it explains the data is self-aggregating, derived from CF analytics-engine, contains no PII, and is cached for 5min to 1 hour depending on window. This aligns with the readOnlyHint and idempotentHint annotations without contradiction.

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

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

The description is appropriately concise (four sentences) and front-loaded with the core purpose. Each sentence serves a clear function: stating returns, listing use cases, and explaining data provenance and caching. No unnecessary words.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description covers all essential aspects: purpose, usage context, parameter semantics, data source, caching behavior, and privacy considerations. It leaves no critical gaps.

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

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

The input schema covers the only parameter 'window' with a concise description, but the description adds practical guidance ('shorter windows surface what's hot right now; longer windows show steady-state demand'), which enriches the agent's understanding of parameter selection.

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 top tools, packs, and call volume over a recent window, using the verb 'returns' and specifying the resource. It distinguishes itself from sibling tools like 'discover_tools' by focusing on trending data and providing concrete use cases.

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, confirming canonical choice, seeing alignment) and explains window options. However, it does not mention when to avoid using this tool or provide direct alternatives among the many 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 indicate readOnlyHint=true and destructiveHint=false; description adds rich behavioral details: searching Polymarket, grouping markets, checking monotonicity, and the reasoning behind cross-event mode. No contradictions.

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

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

Description is moderately lengthy but each sentence adds value—explaining modes, use cases, and return format. Front-loaded with purpose. Slight room for trimming, but well-structured.

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

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

Given complexity (two modes, no output schema), description covers logic, mode differences, and return content (ranked opportunities with reasoning). Could detail input format more, but sufficient.

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

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

Schema coverage is 100% with descriptions for both parameters. Description enhances by explaining the purpose of each mode and providing example values, adding context beyond the schema's basic definitions.

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

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

Description clearly states the tool finds arbitrage opportunities by checking monotonicity violations on Polymarket, with two distinct modes (event and topic). This specific verb+resource pairing distinguishes it from siblings like 'polymarket_edges'.

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

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

Includes detailed guidance on when to use each mode, with concrete examples and even explains why cross-event mode catches cases missed by single-event mode. Lacks explicit when-not-to-use, but highly informative.

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 show readOnlyHint=true, so the description adds value by detailing the process: scanning top markets, grouping by asset, fetching price history once, computing model probability, and ranking by edge. This goes beyond the annotations without contradicting them.

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

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

The description is a single paragraph but efficiently conveys all key points: purpose, scope, process, and output. It could be slightly more structured (e.g., bullet points), but it is not verbose and front-loads 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 the complexity, the description covers the main functionality and intended use. However, it lacks details on return value format (no output schema) and does not explain the model assumptions. It is adequate but leaves some gaps for an AI agent to fully understand the output.

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

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

Schema description coverage is 100%, with each parameter already having a clear description. The tool description does not add significant new meaning beyond what the schema provides, 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 tool's purpose: scanning high-volume Polymarket markets to find where Pipeworz data disagrees most with market price. It specifies the domain (crypto-price bets), model used, and output, distinguishing it from siblings like polymarket_arbitrage.

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

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

The description explicitly frames the tool for the 'what should I bet on today' question, indicating when to use it. It doesn't explicitly state when not to use or mention alternatives, but the context is clear and provides practical 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, idempotentHint=true, and destructiveHint=false. The description adds significant behavioral context: explaining the typical price gap (2-25pp), the two modes of operation, and the return format (leg-by-leg prices and spread). This goes beyond the annotations by describing the tool's internal logic and output structure.

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: first sentence states purpose, second provides market context, then enumerates modes and return format. Every sentence adds value without repetition. Length is appropriate for the complexity.

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

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

Given the absence of an output schema, the description covers the return format (leg-by-leg prices and spread). It explains both input modes sufficiently. However, it lacks details on error conditions (e.g., what happens if a topic has no matching event) or data freshness. Overall, it is largely complete for a read-only tool with good 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 semantics by explaining the two modes (topic vs explicit), listing the pre-mapped topics, and clarifying that explicit parameters override the topic-mapped side. This provides meaning beyond the bare schema descriptions.

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

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

The description clearly states the tool computes cross-venue spread between Kalshi and Polymarket for the same resolving question, with specific verb 'cross-venue spread' and resource 'same resolving question'. It distinguishes itself from siblings like 'polymarket_arbitrage' by focusing on the specific two-venue pairing.

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 implicitly indicates when to use the tool (to find arbitrage signals between two venues) and describes two modes (topic shortcuts vs explicit pairings). However, it does not explicitly state when not to use it or compare with alternatives, but the context is clear enough for an agent.

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?

No annotations are provided, so the description carries full burden. It discloses that the tool retrieves or lists memories, but does not mention any behavioral traits like persistence across sessions, limitations on key format, or what happens if key is missing. Given no annotations, the description is adequate but not rich.

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, clear and front-loaded. No extraneous words. Slightly wordy with 'previously stored' and 'earlier in the session or in previous sessions', but acceptable.

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

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

Given a simple tool with 1 optional parameter and no output schema, the description covers the core functionality. It explains both retrieval modes (by key vs list) and the context of use (previously stored memories). No major gaps for this complexity level.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning by explaining the effect of omitting the 'key' parameter (list all keys) and the purpose ('retrieve context you saved earlier'). This goes beyond the schema's simple 'omit to list all keys'.

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

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

The description clearly states the verb 'retrieve' and the resource 'stored memory', and distinguishes between retrieving by key vs listing all. This differentiates it from siblings like 'remember' and 'forget'.

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

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

The description explains when to use the tool ('to retrieve context you saved earlier') and implicitly distinguishes from 'remember' (store) and 'forget' (delete). However, it does not explicitly mention when not to use it or provide alternative tools for other scenarios.

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

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

No annotations are provided, so the description carries full burden. It discloses parallel fan-out to multiple sources, acceptable input formats (ISO date or relative), and output components (structured changes, total_changes, URIs). No destructive actions or rate limits are mentioned, but for a read-only public data tool, the disclosure is adequate.

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 with no wasted words. The first sentence states the purpose, followed by details on entity type and data sources, then input format and output structure. Information is front-loaded and well-organized.

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

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

Given the tool's complexity (multiple data sources, parallel processing, flexible input formats), the description covers essential aspects: what sources are queried, input format guidelines, and output structure. It does not detail each source's specific output fields, but that is likely acceptable for an AI agent. No output schema is provided, but the description outlines key return values.

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

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

Schema coverage is 100% with clear descriptions for all three parameters. The description adds value by reinforcing acceptable formats for 'since' (e.g., ISO date or relative like '7d') and providing examples for 'value' (ticker or CIK). It also adds implicit guidance on typical usage (e.g., '30d' for monitoring).

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: 'What's new about an entity since a given point in time.' It specifies supported entity type (company), data sources (SEC EDGAR, GDELT, USPTO), and output structure. This distinguishes it from sibling tools like entity_profile (full profile) and compare_entities (comparison).

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

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

The description explicitly recommends using the tool for 'brief me on what happened with X' or change-monitoring workflows. While it does not explicitly list exclusions or alternative tools, the context of sibling tools makes usage clear. The guidance is strong but lacks explicit when-not-to-use instructions.

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?

No annotations are provided, so the description carries full burden. It discloses important behavioral traits: persistence varies by authentication status (authenticated users get persistent memory; anonymous sessions last 24 hours). However, it doesn't mention overwrite behavior (same key overwrites?), storage limits, or data privacy implications.

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

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

Three concise sentences, front-loaded with purpose, then usage guidance, then behavioral note. 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 the simple input schema (2 string params, no output schema, no nested objects), the description covers the essential behavioral aspects. It could mention that values are plain text (already implied) or maximum size limits, but overall it's sufficient for a straightforward key-value store.

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

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

Schema description coverage is 100% and provides clear parameter meanings (key examples, value as any text). The description adds general context but no additional parameter-specific details beyond the schema, so baseline 3 is appropriate.

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

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

The description uses specific verb+resource ('Store a key-value pair in your session memory') and clearly distinguishes from siblings like 'recall' (retrieve) and 'forget' (delete), making its purpose unambiguous.

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

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

The description provides clear context for when to use this tool ('save intermediate findings, user preferences, or context across tool calls') and differentiates persistence based on authentication. It does not explicitly mention when not to use it or compare to alternatives, but the sibling distinction is 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?

No annotations are provided, so the description carries full burden. It discloses that it accepts certain inputs and returns canonical IDs and URIs, implying a read-only operation. However, it doesn't discuss rate limits, authentication, or error scenarios.

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 with no redundancy. Each sentence serves a purpose: stating overall function, providing details, and highlighting benefit. Very concise.

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

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

Given no output schema, the description adequately explains return values (ticker, CIK, name, URIs). It also notes the tool replaces 2-3 calls, which is helpful context. The two required parameters are clearly explained both in schema and 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?

Input schema has 100% coverage with descriptions for both parameters. The description adds value by providing concrete examples (AAPL, CIK) and clarifying the v1 constraint ('type=company'), making parameter semantics clearer.

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 an entity to canonical IDs, specifying verb and resource, and distinguishes from sibling tools which are unrelated (ask_pipeworx, discover_tools, etc.).

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

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

The description explains when to use (to resolve a company entity with ticker, CIK, or name) and that it replaces multiple lookup calls, but does not explicitly state when not to use or mention alternative tools.

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

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

Annotations already indicate readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds that it internally probes each entity with 'ai_visibility_check', ranks results, and returns specific fields (score, confidence, signal density), which are useful behavioral details beyond the annotations.

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

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

The description is a single well-structured paragraph of two sentences, front-loaded with the core purpose and followed by usage context and output format. Every sentence earns its place with no wasted words.

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

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

For a tool with no output schema, the description adequately describes the return format (ranked list with score, confidence, signal density) and explains the internal integration with 'ai_visibility_check'. Given the complexity (comparing multiple entities), this provides sufficient completeness.

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

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

Schema coverage is 100% with good descriptions for all parameters (entities, models, _apiKey, context). The description adds minimal extra semantic value, mostly reiterating what the schema already says, such as 'first entry treated as subject' and 'optional shared context'.

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

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

The description clearly states the verb 'compare' and the resource 'AI visibility across multiple entities', and distinguishes it from the sibling 'ai_visibility_check' which likely handles single entities. The phrase 'side-by-side' and 'ranks' specify the comparative nature.

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

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

The description explicitly states it is 'useful for competitive AI-marketing audits' and implies that for a single entity, one should use 'ai_visibility_check'. However, it does not overtly state when not to use this tool, slightly missing a clear exclusion.

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

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

With no annotations, the description carries the burden. It discloses the mode-dependent vocabulary style (authentic vs. Haiku) but does not mention side effects, rate limits, or output format constraints beyond the schema.

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

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

The description is two sentences long, with no redundant text. The first sentence states the core purpose, and the second explains the two modes efficiently.

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 output schema exists (handling return values), and the tool has 4 optional parameters, the description adequately covers the mode switching. However, it does not explain the severity scale or recipient options, which are left to the schema.

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

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

Schema coverage is 50% (only 'target' and 'translate' have descriptions). The description adds context about omitting 'target' for classical mode, but does not explain 'severity' or 'recipient' even though they have enums. This adds marginal value beyond the schema.

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

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

The description clearly states the tool generates a Shakespearean insult and explicitly distinguishes two modes (classical and targeted), providing a specific verb-resource pairing.

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 each mode ('no target' for classical, 'targeted' for bespoke), but lacks explicit when-not-to-use guidance or comparison with sibling tools, which are in a different domain.

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

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

With no annotations, the description carries the full burden. It discloses the data sources (SEC EDGAR + XBRL), the return verdict structure, and the efficiency benefit. It lacks details on potential errors or prerequisites but is generally transparent about the tool's behavior.

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

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

The description is two sentences with no wasted words. The first sentence clearly states the main purpose, and the second sentence adds crucial scope and return details. It is front-loaded and efficient.

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

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

Given the tool has a single parameter, no output schema, and no annotations, the description provides sufficient context about input format, supported domains, and output structure. It could mention error handling but otherwise covers the essential information for an AI agent to use the tool correctly.

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

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

The schema coverage is 100% for the single parameter 'claim'. The description adds meaningful examples (e.g., 'Apple's FY2024 revenue was $400 billion') and specifies the supported metric types, providing context beyond the schema's minimal description.

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

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

The description clearly states it fact-checks natural-language claims against authoritative sources, specifically company-financial claims via SEC EDGAR + XBRL. It lists return values and distinguishes itself from sibling tools like ask_pipeworx or compare_entities by specializing in factual verification.

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 specifies the supported claim types (company-financial for US public companies) and notes it replaces multiple agent calls. It implies when to use this tool, though it does not explicitly state when not to use it or name alternative tools for unsupported claims.

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