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

Annotations already declare readOnlyHint and idempotentHint as true, so the description does not need to reiterate that. The description provides operational context (1D arrays, specific operations), which adds value beyond annotations.

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

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

The description is front-loaded with the core purpose and uses examples to illustrate. While somewhat lengthy, every part is informative. It could trim redundant phrasing, but overall it's well-organized and scannable.

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

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

Given that an output schema exists (not shown but present per signals), the description adequately covers all operations and parameter roles. The examples demonstrate return values, so no further explanation is needed. Complete for a multi-operation 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?

All parameters have schema descriptions (100% coverage). The description adds meaning by showing concrete examples of how parameters combine (e.g., array1 and array2 for sumproduct, weights for weighted_average), which helps the agent understand usage beyond syntax.

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 performs aggregation operations on 1D arrays, and the examples cover each supported operation (sumproduct, weighted_average, dot_product). The title matches the function, and the tool is distinct from siblings like array_operations and array_statistics.

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?

Usage is implied through examples, but there is no explicit guidance on when to choose this tool over siblings (e.g., array_operations for element-wise operations). No alternatives or conditions 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?

Annotations already declare readOnlyHint and idempotentHint, so the description carries lower burden. It adds context about supporting array-array and array-scalar operations, and provides examples. However, it doesn't mention edge cases (e.g., shape mismatch, type handling) or performance implications.

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

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

Description is concise and front-loaded with purpose. Examples are helpful but could be trimmed or organized as bulleted list. Overall, every sentence adds value, though some redundancy exists.

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 output schema exists and sibling tools are listed, the description sufficiently covers element-wise array operations. It explains supported operation types and input formats. Lacks discussion of return structure, but output schema mitigates this. Adequate for the complexity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds examples for operation, array1, array2, but these illustrate rather than add new semantics. Explanation of context and output_mode remains schema-only. No additional meaning beyond what 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?

Description clearly states 'Perform element-wise operations on arrays using Polars' with specific verb and resource. Examples illustrate common operations. However, it doesn't explicitly differentiate from sibling tools like array_transform or matrix_operations, which may have overlapping capabilities.

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?

No guidance on when to use this tool versus alternatives (e.g., array_aggregate, array_statistics). Description does not specify prerequisites, limitations, or when not to use. The context signal of sibling tools is not leveraged.

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

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

Annotations indicate readOnlyHint=true and idempotentHint=true, and the description adds valuable behavioral context about axis computation modes and output formats, with 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 well-structured with a clear statement of purpose followed by organized examples. It is concise enough, though some examples could be unified.

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 presence of an output schema and the tool's complexity (multiple axes, statistics), the description covers the main use cases through examples, providing sufficient completeness.

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

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

Schema coverage is 100%, so parameters are well-documented. The description provides examples that illustrate parameter usage but does not add new semantic meaning beyond the schema.

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

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

The description states 'Calculate statistical measures on arrays' and provides detailed examples for different axes and multiple statistics. It clearly conveys the tool's function, but does not explicitly differentiate it from sibling tools like 'array_aggregate' or 'statistics'.

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

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

The description gives examples that imply usage across axes and statistics types, but lacks explicit guidance on when to use this tool over alternatives or 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 provides detailed behavioral information, including mathematical formulas, example inputs, and expected outputs for each transformation. Annotations indicate readOnly and idempotent, and the description adds context beyond these, such as the specific calculations. 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 well-structured with a brief intro, a list of transformations, and clear examples. While somewhat lengthy, each sentence adds value. It is front-loaded with the main purpose.

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

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

Given the complexity of four transformations, the description covers all necessary information: purpose, transformations, examples with results, and parameter details. Annotations provide safety guarantees, and the output schema is implied by examples. No gaps.

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

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

The input schema has 100% coverage with descriptions, and the description adds significant value by providing example calculations, explaining the 'transform' options, and clarifying the 'data' format. The 'axis' parameter is also explained.

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: transforming arrays for ML preprocessing and data normalization. It lists four specific transformations with mathematical details, distinguishing it from sibling tools like array_aggregate and array_statistics.

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 data normalization and scaling, but does not explicitly compare to sibling tools or provide when-to-use/when-not-to-use guidance. The examples help, but no alternatives are discussed.

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 include readOnlyHint=true, and the description aligns by focusing on computation without side effects. The description extensively covers execution modes, output modes, error handling, dependency chaining, and response structure, adding significant context beyond annotations.

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

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

The description is well-structured with sections, bullet points, and a code example, making it easy to navigate. However, it is somewhat verbose; a few sentences could be tightened without losing clarity, especially in the Quick Start listing all 20 tools.

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

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

Given the tool's complexity (6 parameters, 20 sub-tools, dependency chaining, multiple modes), the description covers purpose, usage, structure, parameter details, examples, and response format, leaving no gaps for an AI agent to invoke 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?

Input schema has 100% description coverage, but the description adds substantial meaning: it explains execution_mode options, output_mode formats with sizing, how to reference results ($op_id.result), and batch-level context. The example further clarifies parameter usage.

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 executes multiple math operations in a single request with dependency chaining, distinguishing it from sequential individual tool calls. The verb 'execute' and resource 'multiple math operations' are specific, and it differentiates from sibling tools by emphasizing batching.

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' section with checkmarks for multi-step calculations and crosses for single calculations. It also mentions token reduction benefits and references sibling tools in the Quick Start, providing clear guidance on appropriate contexts.

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

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

Annotations declare readOnlyHint=true and idempotentHint=true, but the description goes further by disclosing the use of SymPy, supported functions, and output format through examples. No contradictions are present.

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

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

The description is well-structured with bullet points and clear examples, each earning its place. It is concise yet comprehensive, avoiding unnecessary repetition.

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 existence of an output schema, the description adequately covers usage with examples and parameter details. It could mention error handling or edge cases, but for a calculator tool with clear examples, it is sufficiently 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?

The input schema has 100% coverage, but the description adds value by explaining how to use variables, providing example expressions, and clarifying the context and output_mode parameters 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 the tool evaluates mathematical expressions using SymPy, lists supported operations and functions, and provides diverse examples. It effectively distinguishes itself from siblings like derivative or integral by being a general-purpose calculator.

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 includes examples covering simple arithmetic, trigonometry, and variable substitution, which implicitly guide when to use this tool. However, it does not explicitly state when not to use it (e.g., for array operations or calculus), relying on sibling differentiation.

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

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

Annotations provide readOnlyHint and idempotentHint, indicating safe, deterministic computation. The description adds formulas and example outputs, disclosing the calculation behavior beyond the annotations. No side effects or restrictions are mentioned, but the context 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?

The description is well-structured with formulas followed by concrete examples. It is concise enough to convey essential information without unnecessary verbosity, though the examples could be slightly trimmed.

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

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

Given the presence of an output schema (as indicated in context signals), the description does not need to explain return values. It covers the core functionality, formulas, and common use cases comprehensively for a compound interest calculator.

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

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

The input schema already provides parameter descriptions with 100% coverage. The description supplements with formulas and examples that clarify how parameters are used (e.g., rate as decimal, time in years), adding value beyond the schema.

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

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

The description explicitly states 'Calculate compound interest with various compounding frequencies,' which is a specific verb+resource. It is distinguished from sibling tools like 'perpetuity' and 'financial_calcs' by focusing solely on compound interest calculations.

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 formulas and multiple examples for different compounding frequencies, illustrating when each frequency is appropriate. However, it does not explicitly compare to alternative sibling tools or state when not to use this tool.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds examples of expected conversions but does not detail the output format (though an output schema exists). 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 includes three examples, each adding clarity. It is slightly verbose but well-structured with clear headings. Could be more concise but remains effective.

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

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

With a complete schema and an output schema present, the description covers the essential use cases. It does not mention edge cases (e.g., negative values) but is sufficient for typical use.

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

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

Schema coverage is 100%, and the description includes concrete examples (e.g., value=180, from_unit='degrees', to_unit='radians') that clarify the parameter usage beyond enum lists.

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 'Convert between angle units: degrees ↔ radians' using a specific verb-resource pair. It clearly distinguishes from sibling tools like 'calculate' and 'financial_calcs' which handle different domains.

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 examples of when to use the tool for degrees-to-radians and radians-to-degrees conversions. It lacks explicit 'when not to use' guidance, but the narrow scope makes it clear.

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

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

Annotations declare readOnly and idempotent, which the description supports. It adds behavioral details: NaN for constant variables, spearman handling of non-linear monotonic relationships, and output_format options. 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 well-organized into methods and examples. While slightly lengthy, each section is useful and well-labeled. It could be more concise but structure aids readability.

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 presence of an output schema, the description covers key aspects: methods, output formats, and example results. It adequately addresses typical usage but omits edge cases like missing data handling beyond constant variables.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds value through examples showing usage of 'output_format' and 'method', but does not introduce new information 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 states 'Calculate correlation matrices between multiple variables using Polars' with specific verb and resource. It clearly distinguishes from sibling tools like 'statistics' or 'array_operations' by focusing on correlation methods and output formats.

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 does not explicitly state when to use this tool versus alternatives like 'statistics' or 'array_operations'. Usage is implied through method descriptions and examples, but no direct guidance on context or exclusions is provided.

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

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

The description adds behavioral context beyond annotations: it specifies that results include derivative expression and optionally value_at_point. Annotations already declare readOnlyHint and idempotentHint, so the description complements these without contradiction.

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

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

The description is concise: a single summary sentence followed by clear, well-structured examples. No unnecessary text, and examples are front-loaded to illustrate common patterns efficiently.

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

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

The description covers all major use cases (symbolic, numerical, higher order, partial derivatives, evaluation at point) and includes enough variety to fully guide an agent. The tool has an output schema, so explaining return format is unnecessary.

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 all parameters are well-documented. The description reinforces parameter meaning through examples but does not add substantial new semantic information 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 starts with a clear verb and resource: 'Compute symbolic and numerical derivatives with support for higher orders and partial derivatives.' This is specific and distinguishes the tool from siblings like integral or calculate.

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 multiple examples showing different use cases (first, second, evaluation, product rule, partial derivative), which implicitly guides when to use specific parameter combinations. However, it does not explicitly state when not to use this tool or direct users to alternatives, though the sibling names and context signals make differentiation apparent.

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 and idempotentHint, so the tool's safety profile is known. The description adds value by explaining the sign convention (negative=cash out, positive=cash in) and demonstrating the behavior through examples. No contradictions with annotations.

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

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

The description is well-structured: it starts with a summary, then explains the TVM equation, sign convention, and provides numerous clear examples. Every section serves a purpose, and the length is appropriate for the complexity of the tool.

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 high complexity (11 parameters, 1 required) and the existence of an output schema, the description covers all necessary aspects: all calculation types, sign convention, and multiple scenarios including growing annuity. It leaves no gaps for the agent to understand how to invoke 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?

Input schema covers 100% of parameters with descriptions, but the description enriches meaning by explaining the TVM variable relationships and providing examples that show how parameters like rate, periods, payment, etc., work together. The sign convention adds crucial semantic context beyond the schema.

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

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

The description clearly states the tool's purpose: 'Time Value of Money (TVM) calculations: solve for PV, FV, PMT, rate, IRR, or NPV.' It specifies the resource (TVM calculations) and the action (solve for), distinguishing it from sibling tools like compound_interest or perpetuity.

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 guidance on when to use this tool through the TVM equation explanation and sign convention. It includes multiple examples covering common financial scenarios. However, it does not explicitly mention alternatives or when not to use this tool, like for simple interest calculations which might be better handled by compound_interest.

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 and idempotentHint, confirming no side effects. The description goes beyond by detailing behavioral traits: it distinguishes symbolic (exact) vs numerical (approximate), notes that numerical requires bounds, and shows result formats (e.g., returning an expression or a number). This fully clarifies 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 fairly concise given the complexity; it front-loads the purpose and uses bullet-like examples. However, the examples are somewhat lengthy and could be condensed without losing clarity. Still, every sentence adds value, and the structure is logical.

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 (7 parameters, 2 required, with enums and optional bounds), the description is complete. The output schema exists but is not shown; the description compensates with example outputs. All parameter interactions are clarified, and edge cases (e.g., non-elementary integrals) are covered.

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

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

Despite 100% schema coverage, the description adds significant value through examples showing how each parameter is used (e.g., expression='x^2', variable='x', lower_bound=0, upper_bound=1, method='numerical'). The examples clarify the meaning of bounds and method, and even show the context parameter used implicitly? Actually context is not shown, but the rest is well illustrated.

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

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

The description starts with a clear verb+resource: 'Compute symbolic and numerical integrals (definite and indefinite).' It provides many examples covering indefinite, definite, trigonometric, numerical, and symbolic cases, which distinctly sets it apart from sibling tools like derivative or limits_series.

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 includes extensive examples that implicitly show when to use integrals (e.g., symbolic vs numerical), but it lacks explicit guidance on when to prefer this tool over alternatives or when not to use it. No exclusions or prerequisites are mentioned, which is a gap for an AI agent deciding between tools.

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

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

Annotations declare readOnlyHint and idempotentHint, so the description's task is lighter. The description adds behavioral context through examples showing expected outputs for different inputs, including edge cases like infinity and one-sided limits. It does not contradict annotations.

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

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

The description is front-loaded with the purpose, but the extensive examples make it longer than necessary. While informative, some examples could be consolidated. It is structured but not minimal.

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 (8 parameters, 3 required, 100% schema coverage, output schema exists), the description covers both operations with detailed examples. It provides sufficient context for correct usage, though edge cases like invalid expressions are not addressed.

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

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

With 100% schema coverage, the baseline is 3. The description adds value by showing parameter usage in context (e.g., 'operation=limit' or 'operation=series') and providing concrete result examples, which helps the agent understand how parameters interact.

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

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

The description clearly states the tool computes limits and series expansions using SymPy, with many specific examples covering different cases. The purpose is unambiguous and distinct from sibling tools like derivative and integral.

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 does not explicitly state when to use this tool versus alternatives like derivative or integral. The examples imply its usage for limits and series, but no exclusions or alternatives are provided.

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 and idempotentHint, so the description does not need to restate safety. It adds no behavioral details beyond examples, which are adequate but not necessary 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 verbose with multiple examples. While informative, it could be more streamlined. The purpose is front-loaded, but the length may reduce scanning efficiency.

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

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

Given the complexity of five decomposition types, the description is comprehensive with examples illustrating input and output structures. It complements the output schema by showing result formats in each case.

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 parameters are documented. The description adds value with examples showing exact matrix format and decomposition choices, which clarifies the enum values and required structure.

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 provides matrix decompositions including eigenvalues, SVD, QR, Cholesky, LU. Each is explicitly named and distinguished from sibling tools like matrix_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 lists decomposition types but does not provide explicit guidance on when to use each type or when to avoid the tool. Usage is implied through examples, but no alternatives or exclusions 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?

Annotations already declare readOnlyHint and idempotentHint. The description adds behavioral context by providing concrete examples for each operation, showing input formats and results. It does not contradict annotations and adds value beyond them.

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

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

The description is well-structured with clear headings for each operation and concise examples. While somewhat lengthy, each example serves a purpose and improves clarity. It is not overly verbose.

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

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

The description covers all operations with examples but lacks mention of constraints such as square matrix requirement for inverse or determinant. Given the presence of an output schema, return values are not required. Overall adequate but has 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?

All 5 parameters have schema descriptions, giving a baseline of 3. The description adds significant value by providing specific examples of how each parameter is used, e.g., showing matrix1 and matrix2 values for multiplication, and the result format.

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

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

The description clearly states the tool performs core matrix operations using NumPy BLAS and lists specific operations: multiply, inverse, transpose, determinant, and trace. This distinguishes it from sibling tools like matrix_decomposition and solve_linear_system.

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 explicit guidance on when to use this tool over alternatives such as matrix_decomposition or solve_linear_system. Usage is only implied by the listed operations, but there is no when-to-use or when-not-to-use advice.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safe, non-destructive nature is clear. The description adds behavioral context via examples but does not disclose further side effects or constraints beyond what annotations and schema imply.

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

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

The description is well-structured with clear sections and examples, but it is somewhat lengthy. It effectively communicates the purpose without being overly verbose, earning a high score.

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

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

Given the tool's simplicity, the presence of an output schema, and the examples covering all operations, the description is sufficient for an agent to understand inputs and outputs. It fully addresses the calculation 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%, so the schema already explains all parameters. The description adds marginal value by demonstrating parameter usage in examples, but no new semantic information beyond the schema.

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

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

The description clearly states it performs percentage calculations and enumerates the four supported operations (of, increase, decrease, change) with concrete examples, making the tool's purpose highly specific and distinguishable from sibling tools like compound_interest or statistics.

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 examples of when to use each operation but does not explicitly state when not to use this tool or alternative tools. It lacks explicit usage context, though the examples imply typical use cases.

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 and idempotentHint, so the tool is clearly safe and side-effect-free. The description adds behavioral context about formulas and constraints (r > g for growing perpetuity) but does not reveal additional behavioral traits beyond what annotations convey.

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

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

The description is well-organized with sections for formulas, examples, and context. While it is somewhat lengthy, every sentence serves a purpose. Minor redundancy (e.g., repeating formulas in examples) could be trimmed, but overall clarity is high.

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 annotations (readOnly, idempotent) and the existence of an output schema, the description adequately covers usage context, parameter semantics, and formula constraints. The examples illustrate return values, making the tool complete for its complexity.

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

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

Schema description coverage is 100%, so baseline is 3. The description enriches understanding with concrete examples (e.g., £1000 at 5% yields £20,000) and formula explanations, adding value beyond the schema descriptions 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 calculates present value of a perpetuity, with specific verb and resource. It provides formulas and examples but does not explicitly differentiate from sibling tools like compound_interest or financial_calcs, which also handle cash flows.

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 common contexts (preferred stock, endowments, etc.) but does not specify when to avoid using this tool or mention alternatives. The guidance is implicit through examples but lacks explicit when-to-use versus when-not-to-use criteria.

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 and idempotentHint; description adds meaningful behavioral context by explaining the operation (Polars-based, Excel-like), providing example outputs, and detailing parameter effects like aggregation functions. 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?

Description is well-structured with a clear opening, comparison, and multiple labeled examples. It is slightly long but each example serves a distinct purpose; no wasted sentences.

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 and the presence of an output schema (as noted in context signals), the description fully explains the tool's behavior with diverse examples covering common aggfuncs. No gaps remain for typical use cases.

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

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

Schema coverage is 100% with descriptions for all parameters, so baseline is 3. Description adds value through concrete examples that illustrate parameter relationships (e.g., index, columns, values, aggfunc), enhancing understanding beyond 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 clearly states 'Create pivot tables from tabular data using Polars' and analogizes to Excel pivot tables. Examples demonstrate specific verb+resource (pivot tables) and distinguish from sibling tools like array_aggregate or statistics, 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?

Description provides clear usage context with examples for sum, count, and mean aggregations, implying when to use (reshaping with aggregation). However, it does not explicitly state when not to use or compare to alternatives, leaving slight 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description is not burdened to cover safety. It adds value by detailing each method's rounding behavior (e.g., 'floor: Always round down (3.149 → 3.14)') and showing examples. This clarifies nuances beyond annotations, such as treatment of negative numbers in truncation.

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

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

The description is well-structured with a clear header, method list, and examples. It starts with the purpose and quickly enumerates methods. However, the example section is somewhat repetitive (multiple examples showing similar patterns) and could be trimmed without loss of clarity, earning a 4 rather than 5.

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

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

Given that an output schema exists (per context signals), the description is not required to detail return values. It covers all methods, parameters, and provides comprehensive examples. There are no obvious gaps for a rounding tool; edge cases like very large decimal places are not mentioned but are not critical for basic understanding.

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

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

Schema coverage is 100% with good descriptions for each parameter. The description adds significant value by providing concrete examples for each method and for multiple values, demonstrating the parameter combinations in action. This goes beyond the schema's static descriptions, helping the agent predict outputs.

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 provides 'Advanced rounding operations with multiple methods' and lists four methods (round, floor, ceil, trunc) with explicit examples. This specific verb+resource combination, 'round' with 'Advanced Rounding' title, makes the tool's purpose unmistakable and distinguishes it from mathematical siblings like 'calculate' or 'percentage'.

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

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

The description implicitly guides when to use this tool (for rounding operations) but does not explicitly state when to use it versus alternatives like 'calculate' or 'percentage'. There is no mention of context or exclusions, so the agent must infer usage solely from the tool's name and method list.

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

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

Annotations already indicate readOnlyHint=true and idempotentHint=true, so the description does not need to restate them. It adds value by specifying the use of SciPy's solver and giving result examples, which imply no side effects. 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 front-loaded with the purpose, followed by well-structured examples. While somewhat long, the examples are instructive and not redundant. It could be slightly more concise, but the structure is logical and easy to follow.

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 presence of an output schema (implied), the description covers essential use cases (square, overdetermined, larger systems) with example inputs and outputs. It provides sufficient context for both simple and complex scenarios, making it complete for this tool's complexity.

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

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

Schema has 100% description coverage, but the examples add significant meaning: they show how to structure coefficients and constants as nested lists, demonstrate valid inputs for different system sizes, and clarify the method parameter with concrete use cases. This greatly aids understanding beyond the schema.

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

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

The description clearly states it solves linear systems Ax=b using SciPy's optimized solver, which is a specific verb+resource. The examples with different system types (square, overdetermined) further clarify its purpose and distinguish it from sibling tools like matrix_operations or calculate.

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 explains when to use 'direct' (square systems) vs 'least_squares' (overdetermined systems) via examples. It also shows the syntax for different system sizes, providing clear usage context without leaving 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?

Annotations already indicate readOnly and idempotent behavior. The description adds transparency by detailing the computation types and output structures through examples, clarifying that no side effects occur.

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

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

The description is well-structured with a clear header, bulleted analysis types, and separate examples. It is appropriately detailed without being overly verbose, though some repetition could be trimmed.

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

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

Given the tool's moderate complexity and the presence of an output schema, the description thoroughly explains input parameters, analysis types, and output formats through examples. No critical gaps remain.

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

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

Schema coverage is 100%, but the description adds value by explaining the purpose of each analysis type and providing concrete examples that illustrate parameter usage (data, analyses, context).

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

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

The description clearly states the tool performs 'Comprehensive statistical analysis using Polars' and lists specific analysis types (describe, quartiles, outliers) with detailed examples. This distinguishes it from sibling tools like array_statistics or correlation, which are more specific.

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 basic statistical summaries but does not explicitly state when to use this tool versus alternatives like correlation or array_statistics. No guidance on prerequisites or exclusions is provided.

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