newton

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?

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?

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?

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?

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.