Microsoft Onenote

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

Annotations already mark as read-only, idempotent, non-destructive. Description adds that Anthropic calls require user's own API key, return format includes per-model details, and base model is free. 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, first immediately states core action. Every sentence adds value: default model, key usage, return structure, example use cases. 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 format, parameter roles, and use cases. No output schema, but description sufficiently describes outputs. Could note if rate limits or authentication context exist, but not essential.

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 reinforces parameter purposes (e.g., '_apiKey' needed for Anthropic, 'context' disambiguates) and adds default model behavior 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?

Description clearly states it probes LLMs for entity knowledge and scores visibility (0-100) per model. Specifies default model and optional Anthropic. Differentiates from siblings like 'entity_profile' by focusing on LLM visibility scoring.

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

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

Provides explicit use cases: AI-marketing audits, pre-launch brand checks, competitive monitoring. Does not compare directly to siblings but context is clear; no exclusion note.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds the context of returning structured answers with citation URIs but does not disclose details like rate limits or exact response format.

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 efficiently front-loads the key preference advice. Every sentence adds value without redundancy, though it could benefit from slightly more structured formatting.

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 the tool's return type ('structured answer with stable pipeworx:// citation URIs') and ample usage examples. It is sufficient for an agent to understand the tool's capabilities, though it could specify the answer format more clearly.

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

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

Schema coverage is 100% with parameter descriptions. The description does not add additional parameter-level details beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states the tool routes questions to thousands of verified sources for authoritative structured data, distinguishing it from web search. It uses specific verbs ('routes', 'fills', 'returns') and explicitly lists domains like SEC filings and FDA data.

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

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

The description explicitly instructs to prefer over web search for factual questions, lists numerous example domains and queries. However, it does not specify when not to use or explicitly name sibling tools as 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 extensively discloses behavior beyond annotations: fan-out logic, resolver contract, parent event extractor, news fields, safety mechanisms for low-confidence/closed markets, and edge cases. Annotations already indicate readOnly, idempotent, and non-destructive, and the description is consistent and adds critical 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?

The description is long but well-structured with clear sections (classifiers, fan-out examples, response shapes, resolver contract, etc.). Every sentence adds value, and complex behavior is explained without unnecessary verbosity.

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

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

With no output schema, the description fully explains return fields (market, analysis, evidence, parent_event) and edge cases (low confidence, closed markets, wide spreads). It provides enough detail for an agent to understand and use the tool effectively.

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?

Despite 100% schema coverage, the description adds significant meaning: explains market input flexibility, depth levels with trade-offs, and include_raw with sizing impact. Examples clarify usage beyond schema definitions.

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

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

The description clearly states the tool researches a Polymarket bet by pulling Pipeworx data, and lists input types (slug, URL, question text). It distinguishes from sibling tools like 'polymarket_edges' and 'ask_pipeworx' by specifying use cases such as 'should I bet on X' or 'what does the data say about Y'.

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

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

The description provides explicit use cases and examples, but does not directly state when not to use this tool or compare to specific sibling alternatives. It implies differentiation from edge/arbitrage tools but lacks explicit exclusions.

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 it's read-only and idempotent. The description adds valuable behavioral context: data sources (SEC EDGAR/XBRL, FAERS, FDA), a bug fix, citation URIs, sorting by primary metric. This goes beyond annotations.

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

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

Well-structured with front-loaded purpose and use cases. Every sentence adds value, though the explanation of the fix is slightly verbose. Overall concise 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 high schema coverage and annotations, the description adequately covers inputs, data sources, and sorting. Output format is briefly mentioned (paired data + citation URIs), which is sufficient without an output schema.

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

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

Schema coverage is 100% and descriptions exist. The tool description enriches with examples (tickers, drug names) and clarifies constraints (2-5 items, CIK vs ticker). Adds value beyond schema.

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

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

The description explicitly states it compares 2-5 companies or drugs side by side, with specific data sources and metrics. It distinguishes from sibling tools like 'entity_profile' which handles single entities.

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

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

Clear use cases are provided ('compare X and Y', 'X vs Y', 'which is bigger', rank-by-metric questions) and it mentions replacing multiple lookups. No explicit when-not or alternatives, but the context is sufficient.

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

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

Annotations already indicate read-only, idempotent, non-destructive. The description adds valuable behavioral info: 'Each result is ready to call directly, no second schema lookup needed' and describes the result structure (top-N tools with names, descriptions, full schemas). There is no contradiction with annotations.

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

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

The description is a single dense paragraph that efficiently states purpose, lists domains, describes return value, and gives usage guidance. It front-loads the key information. Could benefit from slight structural separation, but overall concise and informative.

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

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

Given no output schema, the description adequately describes the return value (tools with names, descriptions, full schemas). It mentions curated examples and that results are directly callable. This covers the main use case for a discovery tool without needing further detail.

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% (all parameters have descriptions). The description mentions that query accepts aliases (task, q, description, search) and that limit defaults to 20, max 50, which is already in schema descriptions. No additional semantic value is provided beyond the schema.

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

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

The description clearly states it finds tools by describing data/task and lists many domains (SEC filings, financials, etc.). It distinguishes from sibling tools which are specific tools, and says 'Call this FIRST when you have many tools available', 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?

Explicitly says 'Call this FIRST when you have many tools available and want to see the option set (not just one answer).' It implies when to use but does not explicitly state when not to use or name alternatives. However, the context of siblings makes it clear that this is for discovery, not task execution.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable context: notes about patents soft-failing and a fix for real fundamentals numbers. It does not contradict annotations.

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

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

The description is front-loaded with the main purpose and then details the returns and caveats. While it is relatively long, every sentence adds information that is not redundant with the schema or annotations.

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

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

Given the tool's broad scope (multiple data sources) and the lack of an output schema, the description is remarkably complete. It explains what is returned, notes potential failures, and references a sibling tool. There are no significant gaps.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaning beyond the schema by explaining that 'type' only supports 'company' now and that 'value' can be ticker or zero-padded CIK, with explicit instruction to use resolve_entity for names.

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 'Get everything about a US public company in one call', which is a specific verb+resource. It distinguishes from sibling tools by mentioning it combines data from multiple sources that would otherwise require many separate tool calls, and it lists the returns explicitly.

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

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

The description provides explicit when-to-use scenarios ('tell me about X', 'research Acme', 'brief me on Tesla') and also tells when not to use (names not supported, use resolve_entity first). This helps the agent decide correctly.

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 and idempotentHint=true, indicating it destroys data and is idempotent. The description reinforces this with 'Delete' and adds context on why one might delete (stale context, sensitive data), adding value 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 extremely concise: two sentences with no redundant words. The first sentence defines the core function, and the second provides usage guidance and tool relationships. Every word 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?

For a simple deletion tool with one parameter and no output schema, the description is complete. It clearly states purpose, usage context, and relationships to sibling tools. No additional information is needed.

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 fully documents the single 'key' parameter with description 'Memory key to delete' and an example. The description does not add any additional information about parameter format, constraints, or valid values 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 action 'Delete' and the resource 'a previously stored memory by key'. It distinguishes from siblings by mentioning 'remember and recall' as companions, which helps the agent understand this tool's specific role in memory management.

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

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

The description explicitly states when to use the tool: when context is stale, task is done, or to clear sensitive data. It also advises pairing with 'remember and recall', providing strong usage 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating safe, non-destructive behavior. The description adds context: 'Fetches the page, extracts title/description/key links, and emits standard llms.txt format', explaining the extraction and output behavior 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?

Three tight sentences: purpose, process, and use cases. Every sentence earns its place; no fluff. Front-loaded with the main action.

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 (2 params, no output schema), the description fully covers what it does, how it works, and output format. The three use cases provide sufficient context for an agent to decide when to invoke it.

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 two parameters (url, max_links) described. The description adds meaning by explaining that it extracts title, description, and key links, which clarifies how 'url' is used and that 'max_links' controls link entries. This exceeds baseline 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?

Explicitly states 'Generate a production-ready llms.txt file' with specific target (AI crawlers) and resource (site URL). Clearly distinguishes from sibling tools like 'ai_visibility_check' or 'scan_competitor_ai_presence' through its unique 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?

Lists three concrete use cases (client site indexing, own project drafting, competitor auditing) providing clear when-to-use guidance. Lacks explicit when-not-to-use or alternatives, but siblings are distinct enough to avoid confusion.

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 the tool is not read-only or destructive, but the description adds valuable behavioral details: rate-limited to 5 per identifier per day, free, and doesn't count against tool-call quota. This goes 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 well-structured and front-loaded with purpose. It is slightly verbose but every sentence adds value, covering usage, limitations, and formatting tips.

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

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

Given no output schema and simple parameters, the description is extremely complete. It tells the agent when to use, how to format messages, rate limits, and what to avoid, leaving no ambiguity.

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

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

Schema coverage is 100%, but the description adds extra context for message formatting (e.g., be specific, 1-2 sentences, mention tools/packs). It reinforces the enum choices and explains the context object.

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

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

The description clearly states the tool is used to report bugs, features, data gaps, or praise to the Pipeworx team. It distinguishes itself from sibling tools by focusing on feedback rather than data retrieval or 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 explicitly states when to use this tool (e.g., for bugs, missing features, or praise) and what not to do (e.g., don't paste end-user prompts). It also provides context on how the team uses feedback.

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 (readOnly, idempotent, non-destructive), the description adds valuable behavioral details: caching window (5min-1h), data source (CF analytics-engine), and the fact that no PII is collected. No contradiction with annotations.

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

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

The description is concise, well-structured with bullet points for use cases, and every sentence adds value. No fluff or redundancy.

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

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

Despite no output schema, the description adequately explains what is returned (top tools, packs, call volume) and contextual details (caching, derivation, aggregation). It fully covers the tool's behavior for a simple read operation.

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

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

Input schema has 100% coverage with a description for the 'window' parameter explaining use cases for different windows. The description adds no new information beyond what the schema already provides, 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 a specific verb ('returns') and clearly identifies the resource ('top tools, top packs, and total call volume'). It distinguishes itself from sibling tools by focusing on trending usage signals, not general discovery or Q&A.

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

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

Three explicit use cases are listed (discovering hot sources, confirming canonical choices, checking alignment). While it doesn't explicitly mention when not to use it, the use cases provide clear contextual guidance. It could mention alternatives like 'discover_tools' but is not required.

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 readOnly, openWorld, idempotent, non-destructive. The description adds significant behavioral context: Jaccard similarity threshold (≥0.30), partition filter (drops placeholders, >20% returns null), skipped_low_similarity count, and detailed response structure. 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 comprehensive and front-loaded with purpose and modes. While somewhat lengthy, each sentence adds specific value (e.g., semantic anchor, partition filter, response fields). Minor redundancy could be trimmed, but overall efficient 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?

No output schema exists, so the description must explain return values, which it does thoroughly (opportunities[] with gap_pp, suggested_trade, reasoning, monotonicity violation context; partition_check object). It covers all use cases, edge cases (placeholders, similarity filtering), and response structure, making it complete 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 describes two parameters with 100% coverage but brief explanations. The description adds rich semantics: how event mode walks child markets and runs partition_check, how topic mode searches related events and flattens markets. Example queries and mode-specific behavior far exceed schema detail.

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

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

The description clearly states the tool finds arbitrage opportunities on Polymarket via monotonicity violations and partition-sum checks. It explicitly defines two modes (event and topic) and contrasts with sibling tools like polymarket_edges and polymarket_kalshi_spread, ensuring distinct purpose.

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

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

The description explains when to use each mode: event for a single event slug, topic for a seed question with cross-event search. It implies when not to use (e.g., no partition or cross-event needed) but does not explicitly list alternative tools. Context from siblings fills the gap.

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

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

Annotations already indicate read-only, idempotent, non-destructive behavior. The description adds extensive behavioral details: three model families with specific algorithms, caching at 1h, edge calculation with slippage and 24h-move warnings, diagnostics for empty segments, and knob-based filtering. 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 thorough but quite long and dense, with significant technical detail that may overwhelm some agents. It is well-structured with segments and lists, but could be more concise by trimming less critical implementation details.

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

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

Given the complexity (9 parameters, no output schema), the description covers the response structure (by_segment, diagnostics), caching, edge case handling (Fed bets, empty segments), and provides practical usage notes. It is complete enough for an agent to understand what to expect and how to configure the tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds extra layer of meaning for several parameters (e.g., explaining why min_kelly doesn't apply to partition opportunities, detailing slippage assumptions, and defining tradeable-edge knobs). This goes beyond just restating 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 scans Polymarket markets and returns opportunities where Pipeworx data disagrees with market price, explicitly positioning it as a daily betting discovery tool. It distills among siblings by focusing on disagreement-based edge detection, not general arbitrage or research.

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

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

The description provides strong context for when to use the tool ("what should I bet on today") and includes notes on Fed bets being excluded from ranking with an explanation. However, no explicit when-not-to-use or comparison to sibling tools like polymarket_arbitrage or bet_research is given.

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

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

Annotations indicate read-only, idempotent, non-destructive. The description adds extensive behavioral context: compatibility_warning conditions, temporal_alignment, skipped_cross_type/subtype counters. Explains when spreads are invalid due to non-equivalent bet shapes or temporal gaps. 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 long but well-structured with sections (TWO MODES, RESPONSE, SAFETY FIELDS). Front-loaded with purpose. Some redundancy (e.g., repeating pre-mapped list), but overall efficiently packed with useful 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?

No output schema, but description details response structure: leg-by-leg prices, matched spreads with top_spreads_pp, compatibility_warning, temporal_alignment, skipped counters. For a complex cross-venue tool with safety caveats, 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 covers 100% of parameters with descriptions. The description adds context that topic is a shortcut and explicit params override, but does not add meaning beyond what schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool computes cross-venue spreads between Kalshi and Polymarket for the same resolving question. It specifies the verb 'cross-venue spread' and resource, and distinguishes from siblings like polymarket_arbitrage by focusing on same-outcome comparison across 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?

Explicitly describes two modes (topic shortcuts vs explicit tickers) and when to use each. Warns that pre-mapped topics may not be tradeable via compatibility_warning. Does not explicitly contrast with alternatives like polymarket_arbitrage, but provides clear context for use.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds value by explaining that data is scoped to an identifier (anonymous IP, BYO key hash, or account ID), which is not in annotations. 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 3 sentences, each serving a purpose: stating the action, providing use cases, and mentioning scoping and companion tools. No wasted words, well 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?

The description covers purpose, usage, scoping, and companion tools. The only missing element is return format, but for a tool that retrieves a string value or lists keys, this is not critical. The richness of the description compensates for the lack of output schema.

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

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

Schema coverage is 100% with a clear description for the 'key' parameter: 'Memory key to retrieve (omit to list all keys).' The description reinforces this usage pattern and adds context about listing all keys. Baseline is 3, and the description provides additional clarity, so 4.

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

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

The description clearly states the tool's action: 'Retrieve a value previously saved via remember, or list all saved keys.' It provides concrete examples like 'user's target ticker, an address, prior research notes,' and distinguishes from siblings by mentioning 'Pair with remember to save, forget to delete.'

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

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

The description explicitly states when to use the tool ('Use to look up context the agent stored earlier') and implies alternatives by pairing with 'remember' and 'forget.' It also mentions scoping to the agent's identifier, providing clear guidance on invocation 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 already indicate read-only, open-world, idempotent, and non-destructive traits. The description adds rich behavioral context: parallel fan-out to SEC, GDELT/GNews, USPTO; fallback behavior; soft-fail for patents. 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?

Front-loaded with purpose and examples. Contains technical details about sources and fallbacks which are necessary for correct invocation but could be slightly more concise. 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?

No output schema provided, but the description explains the return structure (changes[] grouped by source, total_changes count, citation URIs). Covers parameter usage, fallback behavior, and source specifics. Slightly incomplete regarding output format details but adequate given the tool's complexity.

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

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

Schema coverage is 100% with descriptions. The description adds meaningful context: explains 'since' accepts ISO date or relative shorthand with examples, and 'value' can be ticker or CIK. Provides typical monitoring value for 'since'. Minor deduction for not explaining how 'type' is used beyond company.

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

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

The description clearly states the verb ('What's new') and resource ('a company'), with specific examples ('what's happening with X', 'updates on Y'). It explicitly distinguishes from the sibling tool 'entity_profile', which handles static profiles.

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

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

Provides explicit when-to-use scenarios ('change-monitoring') and when-not ('use entity_profile instead for static profile'). Details the internal fan-out to multiple sources, aiding agent decision-making.

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 idempotentHint=true and destructiveHint=false. The description adds value by explaining scoping by identifier, persistence duration (24 hours for anonymous), and that it is a write operation. 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 three well-structured sentences. The first sentence fulfills purpose, the second provides usage guidance, and the third covers scoping and pairing with siblings. Every sentence adds value without redundancy.

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

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

For a simple tool with 2 required params and no output schema, the description is complete. It covers purpose, when to use, behavior across sessions, scoping, and links to recall/forget. 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 description coverage is 100%, so baseline is 3. The description adds examples (e.g., 'subject_property') but does not significantly extend beyond the schema's descriptions. It clarifies that value can be any text, which matches the schema.

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

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

The description opens with a clear statement of purpose: 'Save data the agent will need to reuse later.' It specifies the resource (key-value storage) and distinguishes from sibling tools by naming recall and forget. The scope (across conversations/sessions) is explicitly stated.

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 guidance: 'Use when you discover something worth carrying forward...' It explains the benefit (avoid re-lookup) and mentions persistence details (authenticated vs anonymous). It does not explicitly state when not to use, but the context 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 significant behavioral context: it cascades through several lookup endpoints internally, and specifies return values for each entity type (company: ticker, CIK, name, citation URI; drug: RxCUI, ingredient, brand, citation). This fully discloses internal complexity.

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: purpose, usage, supported types, return details. It is dense but every sentence adds value. Slightly verbose in the type details but necessary for clarity.

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 thoroughly explains return values for both entity types and input formats. It covers the internal cascading behavior. Missing error handling or rate limits, but for a lookup tool this is acceptable.

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

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

Although schema coverage is 100%, the description adds meaning beyond the schema. For 'company', it explains that value can be ticker, CIK, or company name with auto-disambiguation. For 'drug', it clarifies brand or generic name. This enriches the parameter semantics beyond the basic enum and description.

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

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

The description clearly states the tool's purpose: resolving user-spoken names to canonical identifiers. It uses specific verb 'resolve' and resource 'names to IDs', and distinguishes itself from siblings by emphasizing 'Use FIRST when you have a name but need an ID.'

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

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

The description explicitly says 'Use FIRST when you have a name but need an ID,' providing clear guidance on when to use. It also mentions that it replaces multiple manual lookups. However, it does not explicitly state when NOT to use it, leaving some ambiguity.

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

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

Beyond annotations (readOnly, idempotent, openWorld, non-destructive), the description explains it probes each entity with ai_visibility_check and returns a ranked list with score, confidence, and signal density. This adds concrete behavioral context without contradicting 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, no wasted words, front-loaded with the main purpose. Every sentence adds value: purpose, mechanism, and output.

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 that compares multiple entities using an underlying tool, the description fully explains what it does, how it works, and what output to expect. No output schema is needed as the return format is described adequately.

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 extra meaning by explaining that the first entity in the array is treated as the 'subject' and the rest as competitors, which is not in the schema description. It also clarifies the overall process.

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

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

The description clearly states the tool compares AI visibility across multiple entities side-by-side, with specific actions: probes each entity with ai_visibility_check, ranks by score, and surfaces most/least recognized. It distinguishes itself from the sibling ai_visibility_check by being a comparative wrapper.

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

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

It explicitly states usefulness for competitive AI-marketing audits and gives an example question, providing clear when-to-use context. It implicitly suggests using ai_visibility_check for single entities, but does not give explicit when-not-to-use or 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?

Discloses behavioral traits beyond annotations: bundlephobia's first measurement can take 5-30s, partial failures degrade gracefully with sources_failed listed, and return structure. No contradiction with annotations (readOnlyHint, openWorldHint, idempotentHint, 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?

The description is a single well-structured paragraph with no wasted words. Every sentence contributes essential information: purpose, usage, return format, and limitations. It is concise yet comprehensive.

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 (composite check, multiple sources, partial failures), the description covers all necessary context: what it returns, sources used, NPM-only limitation, and startup time for bundlephobia. Despite lacking an output schema, the explanation of the summary block and error handling is 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%, so baseline is 3. The description adds value by explaining that 'package' accepts scoped names and 'version' defaults to latest, but this largely matches schema descriptions. It does not add new parameter semantics beyond usage 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 tool's purpose as a composite check for deciding whether to add an npm package, specifying the verb 'check', the resource 'npm package', and the scope 'should I add this to my project'. It distinguishes itself from sibling tools by detailing its unique cross-source 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?

Explicitly says 'Use whenever an agent asks "is X safe / popular / small" or "what does adding lodash cost me"', providing clear usage context. Also specifies exclusions: 'NPM ecosystem only in v1; PyPI / Maven / Cargo / Go fall under deps.dev:version directly', directing to alternatives.

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

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

The description goes well beyond the annotations (which already mark the tool as read-only, idempotent, and non-destructive) by detailing the tool's behavioral traits: it returns a verdict with five possible values, extracted structured form, actual value with citation, and percent delta. It also states that it replaces 4–6 sequential calls, providing transparency about its efficiency and composition.

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

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

The description is concise and well-structured: it starts with the primary action, then usage guidance, then scope limitation, then output details, and finally a comparison benefit. Every sentence adds value, and no redundant or extraneous information is present.

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 moderate complexity (single parameter, no output schema), the description is nearly complete. It explains the input, the output format (verdict types, structured form, citation, delta), and the domain limitation. However, it does not explain what 'pipeworx:// citation' means or handle edge cases (e.g., ambiguous claims), leaving minor 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 already has a good description for the 'claim' parameter with examples, and the description adds further context by providing additional examples and clarifying the supported claim types (company-financial). This adds meaning beyond the schema, though the schema coverage is 100%, so the extra value 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: to fact-check, verify, or refute natural-language claims against authoritative sources, with a specific focus on company-financial claims via SEC EDGAR. It uses specific verbs ('fact-check', 'validate') and explicitly distinguishes itself from siblings by indicating it replaces multiple sequential calls, leaving no ambiguity about what it does.

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

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

The description provides explicit guidance on when to use the tool ('when an agent needs to check whether something a user said is true') and includes example queries. It also specifies the domain limitation (v1 supports company-financial claims), which implies when not to use it. While it does not name alternative tools, the context from sibling tools clarifies differentiation.

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