newton

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, which establish safety. The description adds valuable behavioral context: probing Anthropic requires a BYO key and calls go to api.anthropic.com (external cost). No contradictions.

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

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

Three sentences: first defines core purpose and default, second explains key requirement and cost, third outlines output structure and use cases. Front-loaded with essential info, 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 complexity (multi-model probing, optional keys, score output), the description covers main purpose, default behavior, key requirement, return structure (per-model fields and combined view), and use cases. It could detail scoring methodology or error handling but is sufficient for agent invocation.

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

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

Schema coverage is 100%, so each parameter has a description. The tool description adds extra meaning: default model, cost implication for _apiKey, and disambiguation purpose for context. This elevates understanding beyond the schema alone.

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

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

Description uses specific verb 'probe' and clearly states the resource (LLMs for what they know about an entity) and the output (visibility score 0-100 per model). It distinguishes itself from siblings like scan_competitor_ai_presence by focusing on general brand/business visibility and supporting multiple models with optional BYO key.

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

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

Description provides clear usage context: AI-marketing audits, pre-launch brand checks, competitive monitoring. It explains default model and when to use the _apiKey for Anthropic. However, it does not explicitly exclude or compare to alternative tools like scan_competitor_ai_presence, 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?

With no annotations provided, the description carries full burden and does well by explaining key behaviors: Pipeworx picks the right tool, fills arguments automatically, and returns results. It doesn't mention rate limits, authentication needs, or error handling, but covers the core workflow adequately.

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

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

The description is efficiently structured: first sentence states core functionality, second explains the automation benefit, third provides concrete examples. Every sentence adds value with zero wasted words, making it easy to understand quickly.

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

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

For a single-parameter tool with no output schema, the description provides good context about what the tool does and how to use it. It could mention response format or error cases, but given the simplicity and the examples provided, it's mostly complete for agent understanding.

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

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

Schema description coverage is 100%, so the schema already documents the single 'question' parameter. The description adds context by emphasizing 'natural language' and providing examples, but doesn't add significant semantic detail beyond what the 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's purpose with specific verbs ('ask a question', 'get an answer') and resources ('best available data source'). It distinguishes from siblings by emphasizing natural language processing and automated tool selection, unlike tools like 'derive' or 'integrate' which likely require structured inputs.

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

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

The description provides explicit usage guidance: use when you want to ask questions in plain English without browsing tools or learning schemas. It gives clear examples ('What is the US trade deficit with China?') and contrasts with implied alternatives (manual tool selection).

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's addition of fan-out behavior and evidence packet return provides useful 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?

The description is four sentences, each providing essential information. It is front-loaded with the core purpose. Slightly verbose but efficient overall.

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), the description covers the input format, behavior, output (evidence packet + comparison), and context for use. No output schema exists, but the description compensates 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%, but the description adds clarity for the market parameter (slug, URL, or question text) and for depth (quick vs thorough with defaults). This adds meaning beyond the enum values.

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

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

The description clearly states it researches Polymarket bets by pulling Pipeworx data. It specifies the action and resource, and distinguishes from siblings like ask_pipeworx and derive by focusing on Polymarket bets specifically.

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

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

The description provides explicit use cases: 'should I bet on X?', 'what does the data say about this Polymarket market?', or 'is there edge in this bet?'. It also positions it as the core demo product, implying it should be used before other discovery tools. However, it does not explicitly state when not to use it.

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

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

The description discloses the data sources (SEC EDGAR for companies) and the return format (paired data + pipeworx:// URIs). It does not cover potential limitations, errors, or side effects, but given no annotations, it provides reasonable transparency.

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

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

The description is three sentences, directly states the purpose, gives type-specific details, and includes a performance note. No unnecessary words—every sentence earns its place.

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

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

The description fully covers what the tool does, what it returns, and the two parameter types with examples. Given no output schema, it provides sufficient context for the 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?

Both parameters are described in the schema, and the description adds value by giving concrete examples and explaining how values differ by entity type, enhancing understanding beyond the schema alone.

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

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

The description clearly states the tool compares 2–5 entities side by side, specifies two entity types (company and drug) with associated attributes, and highlights it replaces multiple sequential calls. This differentiates it from sibling tools like 'resolve_entity'.

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

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

The description explains when to use this tool (for comparing multiple entities in one call) and the type-specific parameters, but does not explicitly mention when not to use it or how it relates to other sibling tools beyond the implied efficiency gain.

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 provided, the description carries the full burden of behavioral disclosure. It states the tool computes derivatives, implying a read-only operation, but does not address potential errors (e.g., invalid input), performance considerations, or output format details. The description adds minimal context beyond the basic function.

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, efficient sentence that front-loads the core purpose and includes a helpful example. Every word earns its place, with no redundancy or unnecessary elaboration, making it easy to parse quickly.

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

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

For a simple tool with one parameter and high schema coverage, the description is adequate but lacks depth. Without annotations or an output schema, it does not cover error handling, output format, or limitations, leaving gaps in understanding the tool's full behavior in more complex scenarios.

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

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

Schema description coverage is 100%, so the schema already documents the 'expression' parameter with examples. The description adds marginal value by reinforcing the parameter's purpose and providing an additional example ('x^2' → '2 x'), but does not explain syntax constraints or edge cases 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 specific action ('Compute the derivative') and resource ('mathematical expression'), and distinguishes from sibling tools like 'integrate' and 'simplify' by focusing on differentiation. It provides a concrete example ('x^2' → '2 x') that illustrates the transformation.

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

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

The description implies usage for mathematical differentiation tasks, but does not explicitly state when to use this tool versus alternatives like 'integrate' or 'simplify'. It lacks guidance on prerequisites or exclusions, such as handling non-differentiable expressions or specifying the variable of differentiation beyond the implied 'x'.

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 provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's a search operation ('search the Pipeworx tool catalog'), returns results ('returns the most relevant tools with names and descriptions'), and has a specific use case (large catalogs). However, it doesn't mention potential limitations like rate limits, authentication needs, or error conditions, which would be helpful for a tool with no 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 highly concise and well-structured in two sentences. The first sentence states the purpose and output, while the second provides critical usage guidance. Every word earns its place, with no redundancy or fluff, making it easy for an AI agent to parse quickly.

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

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

Given the tool's moderate complexity (search function with 2 parameters), 100% schema coverage, and no output schema, the description is largely complete. It covers purpose, usage context, and output format. However, without annotations or an output schema, it could benefit from more detail on behavioral aspects like error handling or result structure, but it's sufficient for effective use.

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

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

The schema description coverage is 100%, so the schema already fully documents both parameters (query and limit). The description adds no additional parameter semantics beyond what's in the schema—it doesn't explain parameter interactions, provide examples beyond the schema's query examples, or clarify edge cases. This meets the baseline of 3 when schema coverage is high.

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 with specific verbs ('search the Pipeworx tool catalog') and resources ('tool catalog'), and explicitly distinguishes it from siblings by emphasizing it should be called 'FIRST when you have 500+ tools available and need to find the right ones for your task.' This provides clear differentiation from other tools like derive, factor, integrate, and simplify.

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

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

The description provides explicit usage guidelines: 'Call this FIRST when you have 500+ tools available and need to find the right ones for your task.' This gives clear context on when to use it (large tool catalogs, initial discovery) and implies alternatives (other tools like derive, factor, etc.) should be used after discovery. The guidance is specific and actionable.

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 the call replaces 10–15 sequential agent calls and returns pipeworx:// citation URIs. No annotations exist, so description carries burden; it is mostly transparent but doesn't explicitly state it is read-only or idempotent.

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 core purpose, then specifics, then usage guidance. Ideal length for quick comprehension.

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 enumerates key return elements (SEC filings, revenue, patents, news, LEI, citation URIs). This is sufficient for a profile tool with two simple parameters, though additional details on pagination or error handling would be welcome.

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?

Adds significant context beyond the schema, explaining that type only supports 'company' for now and that value accepts ticker or CIK but not names, directing to resolve_entity for names. Schema coverage is 100% but description enriches understanding.

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

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

The description clearly states it returns a full entity profile across multiple Pipeworx packs, listing specific data types for company entities. It distinguishes itself from sibling tools like resolve_entity (name resolution) and usa_recipient_profile (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?

Explicitly says when to use (comprehensive profile) and when not (use usa_recipient_profile for federal contracts). Also notes to use resolve_entity first if only a name is available, preventing misuse.

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 of behavioral disclosure. While it describes the core function (factoring polynomials with examples), it lacks details on error handling (e.g., invalid inputs, unsupported expressions), performance characteristics, or output format beyond the examples. This leaves gaps in understanding how the tool behaves in edge cases.

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 and front-loaded, stating the purpose clearly in the first phrase and using two illustrative examples that efficiently demonstrate the tool's functionality. Every sentence (and example) earns its place by reinforcing understanding without unnecessary elaboration.

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 low complexity (one parameter, no annotations, no output schema), the description is adequate for basic use but incomplete for robust agent interaction. It covers the core purpose and examples but lacks details on output format, error conditions, and limitations relative to sibling tools, which could hinder effective tool selection and invocation.

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

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

The schema description coverage is 100%, with the parameter 'expression' fully documented in the schema. The description adds minimal value by repeating the parameter concept in the examples but does not provide additional syntax, constraints, or format details beyond what the schema already states. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Factor a polynomial expression') and provides concrete examples that illustrate the transformation from input to output. It distinguishes this tool from sibling tools like 'derive', 'integrate', and 'simplify' by focusing specifically on factorization rather than differentiation, integration, or simplification.

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

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

The description implies usage through the examples (e.g., factoring quadratic expressions), but it does not explicitly state when to use this tool versus alternatives like 'simplify' or 'derive'. There is no guidance on prerequisites, limitations (e.g., polynomial degree), or exclusions, leaving usage context somewhat ambiguous.

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 of behavioral disclosure. While 'Delete' implies a destructive mutation, the description lacks details on permissions needed, whether deletion is permanent or reversible, error handling (e.g., if the key doesn't exist), or side effects. This is a significant gap for a mutation tool.

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, efficient sentence that directly states the tool's action and target. It is front-loaded with the verb 'Delete' and avoids any redundant or unnecessary wording, making it highly concise and 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 the tool's destructive nature and lack of annotations or output schema, the description is incomplete. It fails to address critical behavioral aspects like permanence, error responses, or security implications, which are essential for safe and effective use in a memory management context.

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

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

Schema description coverage is 100%, with the single parameter 'key' documented as 'Memory key to delete'. The description adds minimal value beyond this, only restating 'by key' without explaining key format, constraints, or examples. The baseline score of 3 reflects adequate but not enhanced parameter clarity.

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 specific action ('Delete') and the resource ('a stored memory by key'), making the purpose immediately understandable. It distinguishes this tool from sibling tools like 'remember' (store) and 'recall' (retrieve), establishing its unique 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 provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., that a memory must exist to be deleted), exclusions, or comparisons to siblings like 'recall' (for viewing) or 'remember' (for storing), leaving usage context unclear.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds behavioral context: it fetches the page, extracts title/description/key links, and emits standard markdown. 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 extremely concise, using only three sentences to convey purpose, behavior, and use cases. Every sentence adds value with 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?

Given no output schema, the description fully explains the output as a 'single text blob' in 'standard llms.txt markdown format'. It covers the input parameters and the tool's operations. The annotations provide safety context, making the description complete for this tool.

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

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

Schema description coverage is 100%, so baseline is 3. The description does not add additional semantics beyond the schema; it mentions 'url' and 'max_links' implicitly via the extraction process but no extra detail.

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

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

The description clearly states the tool generates an llms.txt file for a given URL, specifying the verb 'Generate' and the resource 'llms.txt file'. It distinguishes from sibling tools like ai_visibility_check by focusing on producing the standard file format, with explicit use cases for indexing by AI crawlers.

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 use cases (getting a client's site indexed, drafting for own project, auditing competitor's AI visibility), providing clear context for when to use. However, it does not explicitly state when not to use or name alternatives, though siblings exist.

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 discloses the operation (indefinite integration) and variable (x), but lacks behavioral details such as supported expression types, error handling (e.g., for invalid inputs), computational limits, or output format. The description does not contradict annotations (none exist).

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, efficient sentence that front-loads the core purpose and includes a helpful example. Every element earns its place without redundancy or fluff, making it easy to parse quickly.

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

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

For a single-parameter tool with no annotations and no output schema, the description is adequate but has clear gaps. It covers the basic operation and parameter intent, but lacks details on behavioral traits (e.g., error cases, output structure) and does not fully compensate for the absence of structured metadata, leaving the agent with incomplete context.

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

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

The input schema has 100% description coverage, with the 'expression' parameter fully documented. The description adds minimal value beyond the schema by reinforcing the parameter's purpose with examples ('x^2', 'cos(x)'), but does not provide additional syntax, constraints, or format details. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool's purpose with a specific verb ('compute') and resource ('indefinite integral of a mathematical expression'), and distinguishes it from siblings by specifying the operation (integration vs. derivation, factorization, or simplification). The example 'x^2' → '(1/3)x^3' concretely illustrates the transformation.

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

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

The description implies usage for indefinite integration with respect to x, but does not explicitly state when to use this tool versus alternatives like 'derive' (differentiation), 'factor' (factoring), or 'simplify' (algebraic simplification). No exclusions or prerequisites are mentioned.

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 full burden. It discloses the rate limit (5 per day per identifier) and states 'Free' (no cost). It does not detail the exact sending behavior or confirmation, but for a feedback tool this is sufficient.

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 fluff. The purpose is front-loaded, and every sentence adds unique information (what to do, how to do it, constraints).

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 3 params (one nested) and no output schema, the description covers the key aspects: purpose, usage guidelines, and constraints. It could mention that feedback is anonymous or if a confirmation is returned, but the schema covers the input structure 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 value by giving usage hints on how to write the message and that the context should relate to Pipeworx tools/data. This goes beyond the schema's basic descriptions.

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

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

The description states the verb 'send feedback' and specifies the resource 'Pipeworx team'. It lists concrete use cases (bug reports, feature requests, missing data, praise), clearly distinguishing it from sibling tools which serve different purposes.

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

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

The description tells when to use the tool (for feedback types) and provides usage instructions: describe what was tried, avoid including end-user prompts verbatim. It also notes a rate limit. However, it doesn't explicitly state when NOT to use it or suggest alternatives, which would push it to 5.

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: self-aggregating signal, derived from CF analytics-engine, no PII, and caching duration (5min-1h). 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 concise, using bullet points for use cases, and every sentence adds value. Front-loaded with the core purpose, then structured with practical guidance and technical 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 there is no output schema, the description could be more explicit about the output format (e.g., list of objects with tool/pack/count). It mentions what is returned but not structure. For a simple tool, it's mostly adequate, hence 4.

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

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

Schema coverage is 100% and the input schema already provides a detailed description of the 'window' parameter. The tool description repeats that same information without adding new meaning or context, so baseline 3 applies.

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

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

The description uses specific verbs ('returns') and resources ('top tools, top packs, total call volume'), clearly distinguishing this trending/aggregation tool from siblings like ask_pipeworx or discover_tools.

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

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

The description lists three explicit use cases (discovering hot data sources, confirming canonical choice, seeing alignment) and mentions caching behavior, but lacks explicit when-not-to-use guidance or comparisons to alternatives.

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

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

Annotations already indicate read-only and non-destructive behavior. The description adds detailed behavioral context: how each mode works (walks child markets, searches related markets, groups, checks monotonicity) and what is returned. 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 concise, well-structured with clear separation of modes, and every sentence adds essential information. 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?

The description covers both modes, input examples, and output description. It does not address edge cases like missing results or error handling, but given the tool's complexity, it is largely 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 each parameter's role in detail, including examples (e.g., event slug vs. topic seed). This exceeds the schema's descriptions.

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

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

The description clearly states the tool 'finds arbitrage opportunities' via monotonicity checks, and explains two distinct modes. However, it does not differentiate this tool from its sibling 'polymarket_edges', which could be related.

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 each mode (event vs. topic), including when cross-event mode is necessary. It does not explicitly mention when not to use the tool or alternatives like other siblings.

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

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

The description goes beyond the annotations by explaining the underlying model (lognormal from FRED + live coinpaprika price), the process (scan top markets, group by asset, fetch price history once, compute probability, rank by |edge|), and what is returned (top N with trade direction). This fully discloses the tool's behavior and methodology.

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

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

The description is a single paragraph of about 120 words, which is reasonably concise. It front-loads the purpose and then details the process. Every sentence contributes value, though some details could be slightly trimmed. It is well-structured 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?

Despite lacking an output schema, the description clearly explains what is returned: top N ranked by edge magnitude with suggested trade direction. It also covers the model inputs and process, making it self-contained. For a tool of this complexity, the description 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?

All three parameters have descriptions in the schema (100% coverage), so the baseline is 3. The description adds default values (limit=10, window=1wk, min_edge_pp=0.5) but does not provide additional semantic context beyond what the schema already offers. Thus, it scores at 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 clearly states the tool's purpose: scanning high-volume Polymarket markets to find those with greatest disagreement between Pipeworx data and market price. It specifies the verb 'scan' and 'return', the resource 'Polymarket markets', and the outcome 'opportunities based on edge'. It also distinguishes itself from sibling 'polymarket_arbitrage' by focusing on Pipeworx model vs market price.

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 it is built for the 'what should I bet on today' question, indicating when to use it. It also implies that it saves users from manually paging through hundreds of markets. However, it does not explicitly state when not to use it or compare to alternatives like 'polymarket_arbitrage', so it loses one point.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false. The description adds context about the spread calculation and return format, but does not disclose additional behavioral traits such as rate limits or auth requirements. This is adequate given 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 fairly long but well-structured, front-loading the purpose and then detailing modes. Every sentence contributes useful information. Minor conciseness could be achieved, but overall it is 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 no output schema, the description fully explains return values (leg-by-leg prices, spread in percentage points). It covers input modes, constraints, and the underlying logic. This is complete for a tool with no required parameters and comprehensive 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 the schema adequately describes parameters. The description adds value by explaining the two modes and how topic and explicit parameters interact, including the override behavior. This goes beyond the schema descriptions.

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

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

The description clearly states it is a cross-venue spread between Kalshi and Polymarket, explaining the core function with a specific verb ('spread') and resource. It distinguishes two modes (topic vs explicit), which differentiates 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 explains when to use each mode: topic for pre-mapped shortcuts, explicit for custom pairings. It does not explicitly state when not to use or list alternatives, but the context is clear and sufficient for an AI agent to select appropriately.

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 provided, the description carries the full burden. It discloses key behavioral traits: the tool can retrieve from current or previous sessions, and it has dual functionality (retrieve by key vs list all). However, it doesn't mention important aspects like error handling (what happens if key doesn't exist), performance characteristics, or whether listing all memories has pagination/limits.

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 perfectly concise with two sentences that each earn their place. The first sentence states the dual functionality clearly, and the second provides essential context about session persistence. No wasted words or redundant information.

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

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

For a single-parameter tool with 100% schema coverage but no annotations and no output schema, the description is adequate but has gaps. It covers the basic purpose and usage pattern well, but doesn't address what the return values look like (especially important since there's no output schema) or potential limitations of the listing functionality.

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

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

Schema description coverage is 100%, so the schema already documents the optional 'key' parameter and its purpose. The description adds marginal value by reinforcing the dual behavior pattern ('omit to list all keys'), but doesn't provide additional semantic context beyond what's in the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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 with specific verbs ('retrieve', 'list') and resources ('previously stored memory', 'all stored memories'). It distinguishes the dual functionality (retrieve by key vs list all) but doesn't explicitly differentiate from sibling tools like 'remember' or 'forget' which likely handle memory storage and deletion respectively.

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

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

The description provides clear context for when to use the tool ('retrieve context you saved earlier') and includes a usage pattern ('omit key to list all keys'). However, it doesn't explicitly state when NOT to use it or mention alternatives among the sibling tools (e.g., when to use 'remember' vs 'recall').

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?

In the absence of annotations, the description transparently explains behavior: parallel fan-out to multiple sources, accepted date formats, and return structure (structured changes, count, URIs). Minor omissions (e.g., error handling, rate limits) are acceptable given the tool's 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 concise and well-organized: opening defines purpose, subsequent sentences add key details (sources, formats, output, use cases). No redundant or unnecessary 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 no output schema, the description adequately covers return format and all parameters. It could mention potential performance trade-offs (e.g., large results), but overall it is sufficient for an agent to invoke correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds value by suggesting preferred values for 'since' ('30d' or '1m') and clarifying 'value' can be ticker or CIK, complementing the schema descriptions.

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

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

The description clearly states it reports on 'what's new about an entity since a given point in time' and specifies the entity type (company) and data sources (SEC, GDELT, USPTO). While the verb is implied rather than explicit, the purpose is specific and distinct from sibling tools like entity_profile.

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

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

Explicit usage guidance is provided: 'Use for "brief me on what happened with X" or change-monitoring workflows.' This clearly communicates when to invoke the tool, though it does not describe when not to use it or compare with 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively explains key traits: the tool performs a write operation ('Store'), specifies persistence behavior ('Authenticated users get persistent memory; anonymous sessions last 24 hours'), and hints at session scope. It does not cover aspects like error conditions or rate limits, but provides substantial context beyond basic functionality.

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 highly concise and front-loaded, with two sentences that efficiently convey purpose, usage, and behavioral details. Every sentence adds value: the first defines the action and use cases, the second explains persistence rules. There is no wasted text, making it easy for an agent to parse quickly.

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

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

Given the tool's moderate complexity (a write operation with session-based persistence), no annotations, and no output schema, the description does well by covering purpose, usage, and key behavioral traits. It lacks details on error handling or return values, but for a tool with 2 simple parameters and clear scope, it is largely complete and actionable for an agent.

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

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

Schema description coverage is 100%, with both parameters ('key' and 'value') fully documented in the schema. The description does not add any parameter-specific details beyond what the schema provides (e.g., it doesn't explain key constraints or value formatting). Baseline 3 is appropriate as the schema handles the heavy lifting, and the description adds no extra parameter semantics.

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 specific action ('Store a key-value pair') and resource ('in your session memory'), distinguishing it from sibling tools like 'recall' (likely for retrieval) and 'forget' (likely for deletion). It provides concrete examples of what to store ('intermediate findings, user preferences, or context across tool calls'), making the purpose unambiguous and differentiated.

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 offers clear context for when to use this tool ('save intermediate findings, user preferences, or context across tool calls'), which helps guide the agent. However, it does not explicitly state when not to use it or name alternatives (e.g., 'recall' for retrieval or 'forget' for deletion), missing explicit exclusions or comparisons to siblings.

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

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

No annotations are provided, so the description carries the full burden. It explains what the tool returns (ticker, CIK, company name, pipeworx:// URIs), but does not disclose behavior like potential errors, authentication needs, or side effects. With no annotations, this is an adequate but incomplete disclosure.

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

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

The description is three sentences, each earning its place: purpose, detailed version/syntax, and benefit. No redundant or extraneous words. Front-loaded with the core 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?

For a simple tool with two parameters and no output schema, the description effectively explains the output and usage. It covers the main use case (company entities) and the versioning. While it lacks error handling or limitations, it is sufficient for an entity resolution tool.

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

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

Schema coverage is 100%, but the description adds value by providing concrete examples (e.g., 'AAPL', '0000320193', 'Apple') and clarifying that the value parameter can accept ticker, CIK, or company name. This goes beyond the schema's generic 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 resolves entities to canonical IDs across Pipeworx data sources, using specific examples (ticker, CIK, name) and distinguishes from siblings by noting it replaces multiple lookup calls.

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

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

The description implies when to use it (for entity resolution, single call) and states it replaces 2-3 lookup calls, but does not explicitly exclude other tools or provide alternatives for other entity types.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, destructiveHint=false. Description adds behavioral specifics: probes each entity, ranks by score, surfaces most/least recognized, returns ranked list with score, confidence, signal density. No contradiction.

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

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

Description is compact: 3-4 sentences. Front-loads main purpose, then details, then example use case. Every sentence adds value with no fluff.

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

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

Despite no output schema, description specifies return fields (score, confidence, signal density). Covers optional parameters and conditions (models, apiKey, context). Complexity is moderate (4 params, comparative analysis, model selection) and description addresses all aspects.

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

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

Schema coverage is 100%, so descriptions in schema already cover each parameter. The tool description adds value by explaining entities order (first is subject), model options (workers-ai default, anthropic requires _apiKey), and context purpose (disambiguates common 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 the tool compares AI visibility across multiple entities side-by-side, uses ai_visibility_check probes, and returns a ranked list. It distinguishes from sibling ai_visibility_check by targeting multi-entity 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?

Explicit when-to-use context: competitive AI-marketing audits. Implicit alternative: single entity check would use ai_visibility_check. Details on entity ordering (first as subject), models, optional API key, and context field disambiguates usage.

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 of behavioral disclosure. It mentions the tool 'Supports standard algebraic notation,' which adds some context about input format, but lacks details on error handling, performance limits, or output format. For a tool with no annotations, this leaves significant gaps in understanding its behavior.

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

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

The description is front-loaded and concise, consisting of two sentences that efficiently convey the tool's purpose and key feature. Every sentence earns its place by providing essential information without redundancy, making it easy to understand quickly.

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

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

Given the tool's low complexity (one parameter, no nested objects) and high schema coverage, the description is adequate but not complete. It lacks an output schema, and with no annotations, it does not fully compensate by explaining return values or behavioral traits. This results in a minimal viable description with clear 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 has 100% description coverage, with the 'expression' parameter well-documented in the schema. The description adds minimal value beyond the schema by providing an example ('2^2+2(2)'), but does not elaborate on syntax or constraints. Given the high schema coverage, 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 with a specific verb ('simplify') and resource ('mathematical expression'), and provides an example transformation ('2^2+2(2)' → '8'). It distinguishes from siblings like 'derive', 'factor', and 'integrate' by focusing on simplification rather than calculus or factorization operations.

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 ('Simplify a mathematical expression') and mentions support for 'standard algebraic notation,' which helps identify appropriate inputs. However, it does not explicitly state when not to use it or name alternatives among the sibling tools, such as when factorization or integration might be more suitable.

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 return values (verdict, structured form, actual value with citation, percent delta), supported data sources (SEC EDGAR + XBRL), and scope (v1 supports company-financial claims). No annotations to contradict, but could mention more about failure modes.

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, each essential: purpose, scope, and outputs. Front-loaded with action verb. No redundant 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?

Covers tool's purpose, input, output, and use case well. No output schema, but description explains return values. Could mention limitations or error handling for unsupported claim types.

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

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

Only one parameter (claim) with schema description covering it. Description provides examples that add minor value but doesn't significantly extend beyond schema's natural-language claim 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?

Description clearly states the tool fact-checks natural-language claims against authoritative sources, specifies domain (company-financial for US companies), and distinguishes itself by replacing 4-6 sequential agent calls.

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

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

Explicitly describes when to use (fact-checking claims) and mentions efficiency benefit over sequential calls, but doesn't provide explicit when-not-to-use or alternatives beyond mentioning its broader utility.

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