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

With no annotations, the description provides useful behavioral context: 32-bit operation, integer/bitwise not floating, and supported operation set. It does not fully describe edge cases like overflow or result formatting, but the output schema exists to handle return structure, so the description carries an appropriate share of the burden.

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 compact, using a structured 'When/Params/Example' format. Every sentence adds value: use case, parameter values, and a concrete example. No fluff or repetition of schema data.

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 provides essential usage context, parameter details, and an example. Since an output schema exists, it does not need to describe return values. It could slightly improve by stating how results are represented in the chosen base, but overall it is sufficiently 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 description coverage is 0%, and the description compensates strongly by enumerating all op values (add, sub, mul, div, and, or, xor, xnor, not, neg), explaining b is not needed for not/neg, and listing base values (2, 8, 10, 16). It also provides an illustrative example that clarifies expected string inputs.

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 integer/bitwise arithmetic in a chosen base (32-bit), with a specific list of operations. It explicitly distinguishes itself from floating-point evaluation by saying 'not floating evaluate' and names the sibling 'evaluate'.

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

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

It provides explicit when-to-use guidance: 'When: integer/bitwise arithmetic in a chosen base' and explicitly excludes floating-point use by saying 'not floating evaluate'. It also clarifies parameter usage for unary vs binary operations via 'b (except not/neg)' and gives a concrete example.

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

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

With no annotations, the description carries the full behavioral burden. It discloses key behavioral traits: 32-bit fixed size, two's complement encoding for negatives, and the prohibition of leading '-' signs. This goes beyond a simple 'converts bases' statement. However, it does not mention output format or error handling, though an output schema exists.

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 compact and well-structured with 'When:', 'Params:', and a clear example. Every piece of information is useful and not redundant. It packs essential details into a small space.

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 and the existence of an output schema, the description is nearly complete. It covers input semantics, supported bases, and negative-number handling. It lacks a mention of return value or potential errors, but for this straightforward conversion tool with an output schema, the coverage is strong. Minor gaps prevent a 5.

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 0%, so the description must compensate. It does so effectively: 'value' format is explained (no leading '-', FFFFFFFF-style for negatives), and from_base/to_base are constrained to {2,8,10,16}. The example further clarifies usage. This adds meaning entirely absent from 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 the tool converts an integer string between bases 2/8/10/16 with a fixed 32-bit two's complement representation. This is a specific verb+resource+scope that clearly differentiates it from siblings like base_arith (which likely performs arithmetic).

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 opens with 'When: convert an integer string between bases...', providing clear usage context. It does not explicitly name alternatives or exclusions, but the 'When' framing and constraints (bases allowed, two's complement for negatives) offer practical guidance. Missing explicit exclusion of other base conversion 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?

With no annotations, the description carries the behavioral disclosure burden. It does reveal that the tool only works with listed units and that parameters must follow an 'either conversion_id OR from_unit+to_unit' pattern. However, it does not mention error handling, side effects (it is likely read-only, but not stated), or what happens if both modes are supplied. For a simple pure function, this is adequate but not rich.

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

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

The description is extremely concise: three short sentences in a clever 'When:/Params:/Example:' structure. Every sentence carries essential information, with no filler or repetition. It is perfectly front-loaded with the usage condition.

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 and the presence of an output schema, the description is largely complete. It covers when to use, how to specify parameters, and gives an example. It also points to list_unit_conversions for additional context. It does not discuss edge cases or error conditions, but those are not critical for such a straightforward conversion tool.

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

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

The schema has 0% description coverage, so the description must compensate. It explains the parameter relationship: 'value; either conversion_id OR from_unit+to_unit' — a crucial semantic not present in the schema. The example 'value=1, conversion_id="mile_to_km"' concretely demonstrates usage. This adds meaningful value beyond the bare schema definition.

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 function: 'convert between listed measurement units' — a specific verb and resource. It also explicitly excludes free-form dimensional analysis, distinguishing it from more general calculation tools. This is unambiguous and differentiates from siblings like evaluate or base_convert.

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 opens with 'When: convert between listed measurement units (not free-form dimensional analysis)', providing an explicit condition for use. It also gives a direct alternative: 'Call list_unit_conversions first if unsure', which is a clear fallback. This fully satisfies the when/when-not/alternatives criterion.

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 gives a single example but does not describe how negative values, rounding, or precision are handled, nor what the output structure is beyond the example. This is minimal transparency for a conversion 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 extremely concise, using only three short lines to cover when to use, the parameter, and an example. There is no fluff 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?

The tool is simple, and the presence of an output schema reduces the need to describe return values. However, the description lacks edge-case behavior (negative inputs, rounding, seconds precision) and provides only a single idealized example, making it just adequate rather than fully 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 schema has zero description coverage, and the description compensates by stating the parameter `decimal` represents decimal degrees and provides a concrete example mapping decimal=10.5 to degrees=10, minutes=30, seconds=0. This adds meaningful context beyond the bare 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 conversion direction (decimal degrees to degrees/minutes/seconds components) using an arrow notation. It distinguishes itself from the sibling dms_to_decimal by naming the exact direction of conversion, though it lacks an explicit verb like 'convert'.

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 begins with 'When:' and gives a clear condition for use, but it does not explicitly mention alternatives or tell when not to use this tool. It implies usage rather than providing direct guidance compared to sibling tools.

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

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

With no annotations provided, the description carries the burden of explaining its behavior. It discloses that the operation is numerical rather than symbolic and that it evaluates at a single point, which is important behavioral context. It could go further by mentioning approximation characteristics or default step-size behavior, but the core semantics are clear.

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

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

The description is extremely concise, using only two short sentences plus a one-line example. It front-loads the core purpose and packs parameter guidance and an illustrative example into minimal text with no filler.

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

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

Given that an output schema exists, return values need not be described. The description covers the essential invocation context: the expression syntax, evaluation point, optional step, and angle mode. It is slightly incomplete regarding angle_mode values and h defaults, but overall sufficient for an agent to select and 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?

Schema description coverage is 0%, so the description must compensate. It lists all parameters with meaningful hints: 'expression in x', 'at', 'angle_mode', and 'optional h step', and provides a clear example. It does not fully explain accepted angle_mode values or the behavior when h is omitted, but the example and labels provide substantial value beyond the bare 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 exactly what the tool does: computes the numerical derivative df/dx of an infix expression at a point. It explicitly distinguishes itself from symbolic differentiation, making the purpose unambiguous and differentiating it from any symbolic math sibling.

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 frames itself with 'When:' and clarifies this is a numerical derivative at a point, not symbolic, which tells the agent when to use it. However, it does not name any alternative tools (e.g., symbolic differentiation or integration) or explain when a different tool would be preferable.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains that type selects a screen and that all variables needed by that type must be passed, but it does not describe output behavior, error conditions, or side effects. This is acceptable for a calculator-like tool but lacks richer context.

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

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

The description is well-structured and front-loaded: it starts with the key usage condition, then an alternative, then parameter handling rules, a type list, and an example. Every sentence adds value without unnecessary prose or 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?

While the description is helpful, it does not enumerate every valid type string (using wildcards like poisson_* and geometric_*), and some type-specific parameter mappings are omitted. Given the tool's complexity and the lack of enums in the schema, this incompleteness could make it hard for an agent to know exactly which type values and parameters are valid.

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 0%, so the description must compensate. It does so by listing type signatures (e.g., normal_pd (x,sigma,mu)) and providing a concrete example, which meaningfully maps parameters to usage. However, not every parameter or type signature is fully spelled out (e.g., inverse_binomial, poisson_*), leaving some gaps.

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 identifies the tool as handling probability densities, CDFs, inverses, and standardized t values. It explicitly distinguishes this tool from stats_1var for normal distribution from a data list, making the intended use unambiguous.

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

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

The description opens with 'When' to define the exact use context, and explicitly says to use stats_1var(norm_x=…) instead for normal distribution from a data list. This provides clear guidance on when to use this tool versus 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, the description carries the burden and provides a concrete conversion formula, optional parameter defaults, and a worked example. It does not discuss edge cases, but for a simple pure function with an output schema these details are less critical.

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 brief and front-loaded, with a 'When:' opener followed by parameters and an example. Every sentence earns its place, and there is no filler.

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

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

For a simple deterministic conversion tool, the description, input schema, and output-schema signal cover the essential inputs, defaults, and expected behavior. Nothing important is missing at this complexity level.

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

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

Schema description coverage is 0%, and the description fully compensates by identifying degrees as the core value, marking minutes/seconds as optional with defaults, and demonstrating the conversion via a clear example. This adds meaning beyond the bare 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 with 'sexagesimal ° ′ ″ → decimal degrees', a specific verb+resource pairing. The sibling decimal_to_dms makes the opposite direction obvious, so this tool is well 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 leading 'When:' explicitly frames the condition for use: converting from sexagesimal to decimal degrees. It does not explicitly mention when not to use it or directly compare with decimal_to_dms, but the usage context is 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?

Without annotations, the description carries the burden of behavioral disclosure. It explains the formatting rule via example ('value=12345 → "12.345k"'), but does not mention edge cases (zero, negative, very large) or whether the output is a string. It is adequate for a simple formatting tool but lacks depth.

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 short sentences, each serving a purpose: the first states the tool's function, the second gives usage guidance, and the third provides a concrete example. It is front-loaded with the action verb and example, making it highly 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 the tool's simplicity (one parameter, no nested objects) and the presence of an output schema, the description is nearly complete. It explains the purpose, parameter, and example, covering all necessary aspects. It does not describe the return format in detail, but the output schema presumably covers this, per the rubric.

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 only defines 'value' as a number with 0% description, so the description must compensate. The description does so by stating 'Params: value' and giving an example that illustrates the parameter's meaning: the real number to be formatted. This fully explains the parameter's role for this simple case.

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 function: 'show a real number in engineering form (significand + SI symbol)'. It uses a specific verb ('show') and resource ('real number'), which distinguishes it from sibling tools like 'solve_polynomial' or 'base_convert'. It also explicitly points to 'evaluate eng_symbols' as a preferred alternative for expression results, reinforcing its specific scope.

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

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

The description explicitly states 'When: show a real number in engineering form', providing clear context for appropriate use. It also gives an exclusion: 'Prefer evaluate eng_symbols for expression results', telling the agent when not to use this tool. This direct alternative guidance is exactly what usage guidelines should offer.

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 behavioral transparency. It precisely explains the multiplication by 1000^steps, default step behavior, and negative step handling, and provides a concrete example. It omits edge cases or output format details, but for a pure mathematical function these are less critical.

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 well-structured: it starts with a usage cue ('When:'), lists parameters, and provides an example—all in three short sentences with no filler.

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

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

For a simple mathematical tool, the description covers the essential behavior and parameters. The output schema exists, so detailed return-value documentation is not required. The example hints at the output style, and no critical information appears missing.

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 only provides types and a default, while the description adds meaning to 'steps' (negative shifts down) and explains how 'value' is transformed. This compensates for the 0% schema description coverage, though it could elaborate slightly more on 'value'.

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 function: a shift operation for engineering notation by multiplying with 1000^steps. It also distinguishes from the sibling eng_format by specifying 'ENG / ENG← style shift' and gives an example, making the purpose unmistakable.

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 begins with 'When:', indicating appropriate usage context. It also mentions an alternative function 'engshift(x,n)' in evaluate, which guides the agent toward alternative invocation. However, it does not explicitly contrast with other siblings like eng_format, so it is not a full 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?

In the absence of annotations, the description discloses key behaviors: supported numeric domains (real/complex), configurable angle modes (rad/deg/grad), complex output forms (rectangular/polar), and engineering symbol handling. It also gives concrete examples that demonstrate expected behavior. However, it does not describe error handling, return value format, or variable interpolation semantics, leaving some edge-case ambiguity.

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 tightly structured with labeled sections (When, Not for, Params, Example) and front-loads the purpose. Every sentence contributes value, and the examples are concise but illustrative. The text is dense without being verbose, making it easy to scan.

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 covers the fundamental aspects: usage scope, exclusions, parameter details, and worked examples. Minor gaps remain around variable interpolation and complex_form output representation, but these are niche and partially mitigated by the output schema.

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

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

With 0% schema description coverage, the description compensates by enumerating all five parameters with types, defaults, and valid values (e.g., angle_mode=rad|deg|grad, complex_form=rectangular|polar, variables={name:float}, eng_symbols=bool). It even provides examples that illustrate parameter usage. This meaningfully enriches the bare schema, though it could better explain how variables are referenced in expressions and the precise effect of complex_form on the output.

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

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

The description opens with 'When: ordinary infix maths (real/complex), trig, powers, eng suffixes, angle suffixes, polar ∠,' which clearly specifies the tool as a mathematical expression evaluator with particular feature domains. The 'Not for' list explicitly excludes matrices, stats lists, BASE-N, TVM, and unit conversion tables, which distinguishes it from sibling tools and sharpens its purpose.

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

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

The description provides both positive ('When:') and negative ('Not for:') usage guidance. The exclusions map to specific sibling tools (e.g., matrix_op, stats_1var, base_convert, finance_tvm, convert_unit), effectively directing the agent to alternative tools when the input does not fit the evaluator's scope. This is explicit 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?

With no annotations, the description discloses the output behavior via 'factors with multiplicity' and states the input constraints (positive integer, ≤10 digits). It does not mention error handling, but the presence of an output schema and the tool's simple nature reduce the need for that detail.

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 compact and well-structured into 'When', 'Params', and 'Example' sections. Every sentence contributes useful information without redundancy.

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

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

For a simple one-parameter tool with an output schema, the description covers purpose, constraints, and output semantics. The example n=12 further clarifies expected behavior, making the description 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 only defines n as a number, but the description explains it must be a positive integer up to 10 digits. This adds critical semantic meaning that the schema lacks, fully compensating for the 0% schema description 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 performs prime factorization of a positive integer with multiplicity. It also explicitly distinguishes itself from evaluating fact(), which prevents confusion with factorial 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 includes a 'When:' clause specifying the intended use case and notes 'not evaluate fact()' as an explicit when-not. It does not enumerate alternative sibling tools, but provides sufficient guidance for when to choose 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?

No annotations are provided, so the description carries the behavioral burden. It discloses sign conventions ('outflow negative / inflow positive'), defaults (P_Y=1, C_Y=P_Y, begin=False), and the fact that I is an annual percentage, which are non-obvious behavioral details. It does not mention error handling or exact return shape, but the core behavior is well covered.

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 compact and front-loaded, using a 'When' clause to immediately orient the agent. Each sentence adds distinct value—purpose, parameters, sign convention, defaults, and an example—without any repetition or fluff.

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

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

Given the tool's nine parameters and lack of annotations, the description covers the main behavioral rules, defaults, and sign convention, while the output schema handles return values. It could be more complete by specifying invalid-input behavior or edge cases, but it is sufficient for routine TVM problems.

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 0% schema description coverage for 9 parameters, the description fully compensates by naming every relevant parameter and adding meaning: solve_for allowed values, 'provide the other four', annual I, payment/compounding frequencies, and begin flag. The example further maps variables to concrete values, making the parameters actionable.

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

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

The description opens with 'When: time-value-of-money (loan/annuity) — solve one of N,I,PV,PMT,FV', clearly identifying the domain and the action. This differentiates it from sibling math tools by naming its unique TVM variables and purpose.

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

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

The description explicitly states the intended use case ('When: time-value-of-money') and gives concrete invocation guidance: 'solve one of... provide the other four'. It does not name sibling alternatives or exclusions, but the context is clear enough for 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?

With no annotations provided, the description carries the responsibility for behavioral disclosure. It mentions 'approximate', indicating a numerical method, and the 'closed interval' constraint. However, it does not explain behavior for multiple local maxima, error handling, or the effects of the `angle_mode` and `tol` parameters. The description is adequate but not deeply transparent.

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 very brief (three short sentences) and structured with 'When:', 'Params:', and 'Example:'. It front-loads the purpose and includes a concrete example that aids understanding. The 'Params:' list is skeletal but readable. No wasted words, though slightly choppy.

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?

An output schema exists, so return values are covered. However, the description omits details about `angle_mode` and `tol`, does not mention edge cases or limitations, and does not reference sibling tools. It provides a working example but is not fully self-sufficient for an agent unfamiliar with the tool.

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

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

The schema description coverage is 0%, so the description must compensate. It lists parameters and clarifies 'expression in x', and the 'closed interval' gives implied meaning to `lower` and `upper`. However, `angle_mode` and `tol` are unexplained, and the example only uses three required parameters. This is a significant gap for a 5-parameter tool.

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 'approximate maximum of infix f(x) on a closed interval', providing a specific verb ('approximate'), resource ('f(x)'), and scope ('closed interval'). This clearly distinguishes it from sibling tools like fmin (minimum) and other math 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 starts with 'When:' and clearly states the use case for finding an approximate maximum on a closed interval. It does not explicitly mention alternatives or when not to use, but the context is sufficient for an agent to decide. It lacks exclusions but provides a clear 'when to use'.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It honestly notes the 'approximate' nature and 'closed interval' constraint, but does not discuss whether the result is a local or global minimum, or how invalid inputs or non-minimizable functions are handled. This is a moderate gap, but the key computational trait (approximation) is stated.

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

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

The description is extremely concise, using a structured 'When:' line, a params list, and an example. Every sentence has a purpose, and it is front-loaded with the core use case.

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 tool has 5 parameters, 0% schema descriptions, no annotations, and an output schema that may document return values but not parameter details. The description leaves angle_mode and tol unexplained, and misses behavioral nuances (local vs global minimum, error conditions). This is a significant completeness gap 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?

Schema description coverage is 0%, so the description must compensate. It names all four parameters but only gives context for expression ('in x'), lower, and upper (implicitly interval bounds). Angle_mode and tol are left entirely unexplained, and no detail is given on the expression format or acceptable values, which is insufficient for a 5-parameter tool.

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

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

The description clearly states that the tool computes the approximate minimum of an infix function f(x) on a closed interval. This distinguishes it from sibling tools like fmax (maximum) and solve_root (roots), providing a specific verb and resource.

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 leading 'When:' explicitly frames the tool as the one to use when seeking an approximate minimum on an interval, providing clear context. However, it does not mention exclusions or alternative tools (e.g., fmax for maximums), so it earns a 4 rather than 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?

No annotations are present, so the description must convey behavioral traits. It discloses that the integration is numerical and provides a default tolerance, which is useful. But it omits potential numerical pitfalls, angle_mode semantics, or what kind of result to expect.

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

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

The description is extremely concise, using a short 'When' clause followed by a compact parameter list and example. Every word adds value, and the most important context is front-loaded.

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

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

Despite the absence of annotations and schema parameter descriptions, the description covers the core purpose, parameters, and an example. An output schema exists, so return-value details are not necessary. Minor gaps like angle_mode details and numerical caveats prevent a perfect score.

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 0%, so the description must compensate. It lists the parameters and gives an example, adding meaning to 'expression' (in x) and 'tol' (default 1e-10). However, 'angle_mode' is only mentioned by name without explaining its possible values or effect.

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 a 'numerical definite integral of infix f(x) on [lower, upper]', using a specific verb and resource. This distinguishes it from related siblings like differentiate, summation, and product.

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

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

It explicitly frames the tool as 'When ... numerical definite integral', giving clear context for when to use it. However, it does not mention any exclusions or alternative tools, so it lacks explicit when-not-to-use guidance.

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

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

No annotations are provided, so the description must disclose behavior. It says calling with no args returns constants[{name,value,unit,…}], which is useful. However, it doesn't explicitly mention read-only/non-destructive behavior or any other edge cases, though the example implies a safe list operation.

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 short lines, front-loaded with the use case, and every sentence adds value: when to use, parameters, and an example of the output. No wasted words.

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

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

For a tool with no parameters and an output schema present, the description is complete. It explains when to use it, confirms no arguments are needed, and gives a concrete example of the return structure, making it easy 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?

The tool has zero parameters, and the description clearly states 'Params: none' and 'call with no args,' fully covering the input requirements. This matches the baseline for no-parameter tools.

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: 'need CODATA/math constant names (pi, e, qe, …) usable in evaluate.' The example output shows it returns a list of constants with name, value, and unit, distinguishing it from sibling tools like evaluate.

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 'When:' prefix explicitly tells the agent when to use this tool, specifically when needing constant names for use in evaluate. It does not mention exclusions or alternatives, but the context is clear 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?

With no annotations, the description carries the burden of behavioral disclosure. It explains parameter dependencies and provides an example, but does not mention output format, error behavior, or side effects. This adds some context but lacks deeper behavioral details.

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

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

The description is concise and well-structured with 'When:', 'Params:', and 'Example:' sections. Every sentence serves a purpose, and the most important usage context is front-loaded.

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

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

Given the tool's complexity (7 parameters, multiple modes), the description covers the essential usage thoroughly. It lacks some minor details like the meaning of sort_a vs sort_d and angle_mode values, but the presence of an output schema and clear parameter rules make it adequate.

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

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

Schema coverage is 0%, but the description compensates fully by defining op values and explaining which parameters are needed for each op. All 7 parameters are addressed, including the angle_mode for seq expressions. This is far more informative than the bare 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 performs LIST utilities (sequence, cumsum, sort, ΔList) and explicitly distinguishes it from stats summaries. The allowed op values are listed, providing a specific verb+resource for each operation.

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 a clear 'When' clause specifying list utilities and excluding stats summaries, which implicitly guides away from sibling stats tools. It also gives usage rules such as 'seq needs expression,start,end[,step]' and 'others need data', helping the agent choose the correct parameter sets.

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

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

With no annotations, the description carries the burden. It discloses the return format (operations[{name,arity,description,angle_sensitive}]) and confirms no arguments are needed. It does not explicitly state it is read-only or side-effect-free, but that is strongly implied for a list operation.

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

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

The description is extremely concise, using two short sentences plus an example. Every element—when to use, parameter expectations, and return shape—is packed efficiently, with no wasted words.

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

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

This is a simple introspection tool with no parameters and a clear output example. The description covers the trigger scenario and the expected return structure, which is sufficient for an agent to select and invoke it correctly. The output schema (if present) would further detail the fields, but the description already provides the essentials.

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 tool has zero parameters, which yields a baseline of 4. The description reinforces this with 'Params: none' and 'call with no args', leaving no ambiguity about invocation.

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 indicates when to use the tool ('unknown function/operator name... or exploring arity') but does not explicitly state 'list operations' as the core action. The name and example make the purpose clear, and it distinguishes from sibling tools like list_constants and list_unit_conversions.

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 conditions: when an unknown function/operator name appears after evaluate unknown_token, or when exploring arity. It also states 'Params: none' and gives a call example, making it clear how and when to invoke the 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?

With no annotations provided, the description carries the full burden. It discloses that the tool takes no arguments and returns a list of conversion objects, which is sufficient for a simple read-only list operation. It does not explicitly state side effects, but none are expected for a list call.

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, with three short lines covering usage timing, parameters, and an example. Every piece of text adds value; there is no fluff or 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?

For a parameterless tool with an output schema available, the description provides all necessary context: when to use it, that it needs no arguments, and what the return shape looks like. This is complete and self-sufficient.

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

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

The tool has zero parameters, so the baseline is 4. The description confirms 'Params: none,' which is all the parameter semantics needed. The input schema already reflects an empty parameter set.

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 lists unit conversions and explicitly frames it as a precursor to convert_unit. The example output shape (conversions[{id,from,to,…}]) makes the purpose concrete and distinguishes it from the sibling convert_unit tool.

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 explicit timing: 'before convert_unit' and when the conversion_id or unit pair is unknown. It does not list exclusions or alternative tools beyond convert_unit, but the context is clear enough for an agent to decide when to call 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?

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It explains parameter roles but omits return formats, error handling (e.g., singular matrix for inverse), and potential ambiguities like how 'mul' handles two matrices or a matrix and a vector.

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: When, Params, Example. It front-loads the purpose and uses a compact format that conveys essential information without wasted words.

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

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

With 5 parameters and 16 operations, the description covers core usage but lacks detailed behavioral context and edge cases. The presence of an output schema mitigates the need to explain return values, but the single example is not enough to disambiguate all operations.

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

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

The schema has zero descriptions, so the description compensates by defining the op values, matrices, vector, n, and angle_mode. It provides an example and clarifies parameter roles, though it leaves some interaction details ambiguous (e.g., vector usage for angle or cross).

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

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

The description explicitly states the tool handles matrix/vector algebra and distinguishes it from infix evaluate, which is a sibling tool. The purpose is clear and specific, covering a well-defined domain with a list of 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 opening 'When: matrix/vector algebra (not infix evaluate)' provides explicit context for when to choose this tool over the sibling evaluate. It clearly delineates the tool's use case, though it does not name other 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?

No annotations are provided, so the description carries full burden. It discloses the default angle_mode ('deg'), provides an example with expected output, and implies a pure conversion. However, it does not state return format explicitly, error behavior, or that it is non-destructive. The example gives some transparency, but not complete.

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: a 'When' clause, a param line, and an example. Every sentence serves a purpose. It is front-loaded with the key trigger, making it easy for an agent to quickly determine applicability.

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 tool is simple, and an output schema exists (though not shown) which likely describes return values. The description covers the purpose, parameters, and a concrete example. It doesn't mention edge cases or alternative sibling tools, but for a straightforward conversion, it is adequately complete given the output schema.

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

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

The schema description coverage is 0%, so the description must compensate. It introduces x and y as rectangular coordinates and angle_mode for θ, with a default of 'deg'. This adds meaning beyond the bare schema. However, it doesn't enumerate allowed values for angle_mode (e.g., 'rad') or clarify that x and y are numbers (though schema states type). The example helps but is not exhaustive.

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 function: 'convert rectangular (x,y) to polar (r,θ)'. It uses a specific verb ('convert') and identifies the resource (rectangular to polar). It also distinguishes itself from manual calculation by saying 'Prefer over manual atan2', and the sibling 'rec' (likely reverse conversion) is implicitly contrasted by the phrase 'for this mode'.

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 begins with 'When: convert rectangular (x,y) to polar (r,θ)', explicitly stating the condition for use. It also provides a clear alternative to avoid ('manual atan2'), giving practical guidance. While it doesn't mention sibling tools like 'rec', the 'When' clause and preference note are sufficient.

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

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

The description discloses that the range is inclusive and x is integer, but it omits critical behavioral details such as how angle_mode affects trigonometric expressions and what the output looks like. With no annotations, these missing traits leave significant ambiguity.

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 concise sentences: definition, params, and example. Every sentence carries useful information with no redundancy, making it efficient and easy to parse.

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?

An output schema exists, so return values are documented elsewhere. However, angle_mode semantics and allowed expression syntax are left unaddressed, leaving notable gaps. The description is minimally complete but not thorough.

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 description explains expression is in x and start/end are integer bounds via the example, but angle_mode is completely unexplained despite having a default and no schema description. With 0% schema coverage, the description needed to compensate more for this parameter.

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

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

The description clearly states the tool computes the discrete product of f(x) for integer x from start to end inclusive. This specific verb-resource pair distinguishes it from siblings like 'summation' and other math tools.

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

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

The 'When:' phrasing implies usage for product calculations, but it does not explicitly mention alternatives like summation or any exclusions. The guidance is implied rather than directly stated.

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 adds useful context about angle_mode defaulting to degrees, but it does not describe output format, error handling, or edge cases. For a simple pure conversion, this is adequate but not comprehensive.

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. The purpose is front-loaded in the first phrase, followed by parameter details and a clarifying example. Every sentence earns its place with no redundant or vague content.

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 and the presence of an output schema, the description covers the core essentials: operation, parameters, default unit, and example. It does not mention the inverse operation (pol) or potential edge cases, but these are minor gaps for a pure math conversion 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 0%, and the description fully compensates by explaining that r is the radius, theta is the angle, and angle_mode specifies the angular unit (default deg). The example further clarifies usage, adding substantial meaning beyond the bare schema titles.

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 function: convert polar (r,θ) to rectangular (x,y). It uses a specific verb and resource, making the purpose unambiguous. However, it does not explicitly distinguish from sibling 'pol' (likely the reverse operation), so it misses the full mark for differentiation.

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 opens with 'When:' to indicate the specific use case (converting polar coordinates), providing clear context. It does not mention alternatives or exclusions, such as recommending the 'pol' tool for the reverse conversion, so it lacks explicit when-not guidance.

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

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

Discloses the degree range (1–4) and shows a concrete example, but with no annotations, it doesn't describe output format, error handling, or side effects. The output schema covers return values, so some burden is relieved.

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-line structured description with 'When:', 'Params:', and 'Example:' sections. No wasted words, though it could be slightly more verbose for clarity.

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

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

Covers the essential operational context: degree limitation, parameter semantics, and an example. It doesn't explain what the solution looks like, but the output schema exists; for a tool of this simplicity it's adequate.

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

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

Schema has no property descriptions (0% coverage), so the description fully compensates: it defines coefficients as [a0,...,an], lists allowed relation values, and provides a worked example.

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

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

Clearly states it solves polynomial inequalities of degree 1–4, with explicit parameter description and example. Distinguishes from sibling tools like solve_polynomial (equations) and solve_linear by its inequality focus and degree range.

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

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

Provides a 'When:' clause specifying the tool's intended use (polynomial inequality solving). It does not explicitly list alternative tools or exclusions, but the degree constraint and inequality nature imply 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.