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

With no annotations, the description carries the full burden and does well: it discloses the safe-execution mechanism ('Uses an AST whitelist'), documents both success and error return shapes, and warns about syntax pitfalls (implicit multiplication, 'x' as the variable, ** vs ^). It does not discuss limits on expression size or complexity, but for a pure read-only evaluator this is solid disclosure.

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

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

Content is front-loaded (one-line purpose, then supported syntax, then I/O, then examples), and the sections are skimmable. It runs somewhat long — four doctest examples plus a Notes block that partly restates the power-notation point already shown in an example — so a little redundancy keeps it from a 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?

There is no output schema and no annotations, so the description must supply return values, error shape, and safety context itself — and it does all three, plus syntax caveats. An agent has everything needed to call this tool correctly on the first try.

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, and it does: it defines the single parameter as a string expression, supplies four concrete examples, and adds non-obvious syntax rules (variable 'x', mandatory explicit '*', power notation). This is meaning well beyond what the bare schema provides.

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

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

The description states a precise verb+resource ('Evaluates a mathematical expression and returns the result') and enumerates the supported operators, functions, and constants, so the agent knows exactly what class of input is accepted. It stops short of explicitly differentiating itself from symbolic siblings like factorize, expand, or solve_equation, so it is clear but not sibling-aware.

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 by the capability list — an agent can infer this is for numeric evaluation rather than symbolic manipulation — but there is no explicit when-to-use statement and no alternatives (e.g., solve_equation, differentiate) named as the better choice for other tasks. Minimum viable 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?

With no annotations, the description carries the full behavioral burden. It does disclose the success and error return shapes, which is valuable given there is no output schema, but it omits important behavior: distribution/t-distribution assumptions, behavior on empty or single-element data, and validation failures for out-of-range confidence values.

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?

Purpose is front-loaded, and the Args/Returns/Examples structure is scannable. The doctest example with numpy import, random seed, and an ELLIPSIS-pinned numeric output is longer than needed and adds little selection value.

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

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

For a simple two-parameter statistical function with no output schema, the description provides purpose, parameter meaning, and return shapes in both success and error cases. The main gaps are the assumed distribution and edge-case handling, which are secondary 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%, so the description must compensate. It names both parameters and clarifies that 'confidence' is a confidence level (not a count), but largely restates type/default information already present in the schema and never states the valid range (e.g., 0 < confidence < 1).

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?

States a specific verb and resource: computing the confidence interval for the mean of a dataset. This is inherently distinguishable from statistical siblings like mean, variance, and standard_deviation, though the description never explicitly names an alternative or boundary case.

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 mean, variance, or standard_deviation. There is no mention of prerequisites (e.g., minimum sample size) or conditions under which a confidence interval is or isn't appropriate.

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, and it does disclose the return shape ({"result": ...} vs {"error": ...}) plus a worked example. It omits important behavioral facts for this operation: whether the two lists must be equal length, what happens on mismatched lengths or zero-variance input, and whether the computation is pure/side-effect free. Partial disclosure merits a middle score.

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 purpose sentence is front-loaded and the Args/Returns/Examples structure is easy to scan, with a concrete example that removes ambiguity. The Args section is nearly redundant with the schema, so a little trimming is possible, but nothing is bloated.

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?

There is no output schema, but the description covers the return contract for both success and error, plus a concrete example, which is what an agent needs to interpret results. The main gap is the absence of input-validation behavior (length mismatch, constant series) for a two-param tool with zero annotation coverage.

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 labels data_x as "the first list" and data_y as "the second list," which conveys pairing/order but not the key constraint (equal length) that determines success or error. It adds only marginal meaning beyond the schema's array-of-number types.

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 names a specific verb and statistic ("Computes the Pearson correlation coefficient") and the exact inputs ("two lists of numbers"), so the purpose is unambiguous. It does not distinguish itself from statistical siblings such as linear_regression or variance, but the operation is clearly scoped.

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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives among the many statistical siblings (linear_regression, variance, mean). The agent must infer applicability purely from the statistic's name.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return contract for both success ({"result": ...}) and error ({"error": ...}) cases, lists supported function families, and states a hard limitation on implicit differentiation. This is solid behavioral disclosure for a pure computation 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?

Front-loaded with the core purpose, then Args/Returns/Examples/Notes. The four doctest examples are genuinely useful for showcasing notation, though the section headers add modest overhead. Every part mostly earns its place.

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

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

No output schema exists, and the description documents the return shape explicitly for both success and error paths, plus supported operations and syntax conventions. Nothing an agent needs to call differentiate correctly is left unstated.

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 fully. It explains 'expression' with concrete examples ('x**2', 'sin(x)', 'exp(x)') and the notation rules (*, ** or ^), and explains 'variable' including its default of 'x' and that other variables can be supplied.

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?

States a specific verb ('Computes the derivative') and resource ('mathematical expression with respect to a variable'), and the scope (supported function families) sets it apart from siblings like integrate, expand, and factorize. An agent can immediately distinguish it from the 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?

Clearly states the context of use and an explicit exclusion ('Only support for one variable at a time / implicit differentiation not supported'). It doesn't name the natural alternative (integrate) to route the agent, but the domain is well bounded.

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 exist, so the description carries the full behavioral burden. It does disclose the response contract with explicit success ({"result": ...}) and error ({"error": ...}) shapes, which is genuinely useful given there is no output schema. It says nothing about error conditions (malformed/invalid expression), which symbol(s) are assumed, or whether the operation is purely symbolic with no side effects.

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

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

Front-loaded one-line summary followed by Args, Returns, and Examples sections — a clean, conventional structure with no filler. The Args line is slightly redundant with the schema, but overall it is well-sized for a single-parameter 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?

For a low-complexity single-parameter math tool with no annotations and no output schema, the description covers the input and the return contract adequately. It omits the two things an agent would most want here: which symbolic variable/domain is assumed and how this differs from factorize, its inverse sibling.

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% for the single parameter, so the description must compensate. It restates the parameter as 'The expression to expand as a string' (type is already in the schema) but the example adds real meaning by showing the accepted syntax with ** for exponentiation. That is modest added value, not full compensation for the coverage gap.

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?

States a specific verb and resource ('Expands an expression') and the worked example ('(x + 1)**2' -> 'x**2 + 2*x + 1') confirms it is algebraic expansion of products/powers into sums. Clear, but it never distinguishes itself from the natural inverse sibling factorize, so an agent must still reason about which to pick.

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?

There is no when-to-use statement, no mention of factorize as the inverse operation, and no note on prerequisites or expression syntax limits. The example demonstrates a call but that is illustration, not guidance about conditions for selecting this tool over its siblings.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It usefully gives the success and error return shapes and an example, but says nothing about expression syntax assumptions, variable handling, or domain limits. This is adequate but clearly incomplete for full behavioral 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 purpose is front-loaded in one sentence, followed by compact Args, Returns, and Examples sections. Every part is relevant and appropriately sized for a simple math function.

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

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

No output schema exists, but the description provides the return structure for success and error plus a concrete example. It is complete enough to invoke correctly, though it omits routing context relative to siblings like expand and lacks edge-case behavior notes.

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 sole required parameter is documented as "the expression to factorize as a string," which compensates for the 0% schema description coverage. The example further demonstrates valid syntax (e.g., `x**2 + 2*x + 1`), though no formal grammar or edge-case constraints are given.

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?

"Factorizes an expression" gives a specific verb+resource and is unambiguous on its own. It does not differentiate from sibling symbolic tools like expand or solve_equation, so it falls short of a 5.

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

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

The description offers no when-to-use guidance, no exclusions, and no comparison with alternatives such as expand or solve_equation. The provided example implies usage but does not state how to choose this tool over its siblings.

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

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

With no annotations, the description carries the burden and does so well: it discloses the success envelope {'result': ...}, the error envelope {'error': ...}, and the important semantic caveat that the constant of integration is omitted. It stops short of stating anything about expression-size limits or simplification guarantees beyond 'may be returned in simplified form'.

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

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

Front-loaded one-line purpose followed by well-labeled Args/Returns/Examples/Notes sections. The five examples are slightly more than strictly needed, but for a 0%-coverage schema they substitute for parameter documentation and each demonstrates a distinct function class.

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

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

No output schema and no annotations exist, so the description must supply everything, and it covers both return shapes, error behavior, the missing-constant caveat, and result simplification. An agent has everything needed to call this correctly and interpret the response.

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 fully, and it does: the expression argument's expected string syntax is demonstrated with four concrete inputs, and the variable parameter is documented with its default ('x') and the fact that other variables may be substituted, illustrated by integrate("x*y", "y").

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?

States a specific verb and resource: 'Computes the indefinite integral of a mathematical expression with respect to a variable.' The scope word 'indefinite' plus the explicit variable-as-respect-to distinguishes it cleanly from siblings like differentiate and summation, and SymPy support is enumerated.

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 only implied through the worked examples; there is no statement of when to choose integrate over differentiate, calculate, or summation, and no exclusions (e.g. no definite integrals with bounds). Adequate for a self-evident math operation, but no explicit routing 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?

With no annotations, the description carries the full disclosure burden. It usefully documents the return contract (a slope/intercept object on success, an error object on failure) and gives a concrete worked example, which is genuine added value. However, it is silent on edge cases relevant to regression, such as too few points, collinear/degenerate input, or whether the fit is ordinary least squares.

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?

Purpose is stated up front, followed by Args/Returns/Examples in a conventional, scannable layout with no filler. The example is worth its space, though the Returns section partially overlaps with what the example already demonstrates.

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?

There is no output schema, so the description appropriately carries the return format, including the success and error shapes. For a single-parameter deterministic math function this is nearly complete; only edge-case behavior for invalid or insufficient data is unstated.

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 no parameter descriptions exist, but the tool has only one argument and the description fully specifies it as a list of (x, y) coordinate tuples, including positional meaning. That is sufficient for correct invocation, though it does not specify minimum length or duplicate-x handling.

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 names a specific operation (linear regression) and states exactly what it produces (slope and intercept), which cleanly distinguishes it from siblings like correlation_coefficient, mean, or variance that also consume numeric point data.

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

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

It explains what the tool computes but never says when to choose it over alternatives such as correlation_coefficient or a general 'calculate' tool. No preconditions, fitting-method notes, or exclusion criteria are given.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose the response envelope ('On success: {"result": ...}' / 'On error: {"error": ...}'), which is valuable since there is no output schema. However, it omits any constraint that the two matrices must have matching dimensions, which is the main failure mode an agent needs to know about.

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

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

Front-loaded one-line purpose followed by clearly labeled Args, Returns, and Examples sections. Every block earns its place; the Args lines are slightly redundant with the schema types but cheap.

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

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

With no annotations and no output schema, the description supplies the missing pieces: argument shape and the success/error return contract, backed by an example. The only meaningful omission is behavior on mismatched matrix dimensions.

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, and it does: both parameters are named with their expected shape ('as a list of lists'), and the worked example makes the accepted nesting and numeric element type concrete. It adds useful meaning beyond the bare array-of-array 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 first line states a specific verb and resource: 'Adds two matrices.' Combined with the tool name, an agent can immediately distinguish this from matrix_multiplication, matrix_transpose, and matrix_determinant without opening a schema. It stops short of explicitly naming those siblings, so it is clear but not fully 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?

Usage is only implied by the operation itself – the description never states when to pick addition over the other matrix or vector tools, nor any preconditions. For a trivial, unambiguous math operation this is adequate but not instructive.

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 and does disclose key behavioral traits: it specifies the required square matrix input, the success return format, and the error return format. It also provides a concrete example output. However, it omits edge-case behavior such as what happens for non-square matrices or empty inputs beyond a generic error message.

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 purpose statement, argument description, return values, and an example. It is front-loaded and every section earns its place, though the example could be considered slightly redundant for such a straightforward function.

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 function with one parameter, no output schema, and no annotations, the description provides complete information: input shape, output format on success and error, and a concrete example. An agent has everything needed to invoke it 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 does so by clarifying that the 'matrix' parameter is a square matrix given as a list of rows. This adds meaningful semantics beyond the schema, which only specifies a nested array of numbers.

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 a specific verb and resource: 'Computes the determinant of a square matrix.' This clearly distinguishes it from siblings like matrix_transpose or matrix_multiplication, which perform different operations on matrices.

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 explain when to use this tool versus alternatives. While the purpose implies its use for determinant calculations, there is no explicit guidance on context or exclusions relative to other matrix operations in the sibling 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?

With no annotations, the description carries the full behavioral burden and does a decent job: it discloses the success envelope {"result": ...}, the error envelope {"error": ...}, and a worked example. It omits the key constraint that matrix dimensions must be conformable, which is the main failure mode, keeping it out of 5 territory.

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

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

Front-loaded one-line purpose followed by compact Args/Returns/Examples sections, each of which earns its place by supplying information absent from the schema. No filler or restatement of the tool name.

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

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

With no output schema and no annotations, the description supplies the return and error formats plus an example, which is most of what an agent needs. The remaining gap is the absence of any statement about dimensional-compatibility requirements or return type guarantees.

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, and it does: both matrix_a and matrix_b are described as lists of lists, which matches the nested-array schema and clarifies the expected nesting. It adds no constraints on shape or element type beyond that, so it is solid but 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?

States a precise verb and resource: 'Multiplies two matrices.' An agent can immediately distinguish this from matrix_addition, matrix_transpose, and matrix_determinant by the operation itself. However, it never explicitly contrasts itself with siblings like vector_dot_product, which is the closest conceptual neighbor, so it stops short of a 5.

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?

There is no explicit when-to-use, when-not-to-use, or alternative-naming guidance. For a mathematical primitive the intended usage is strongly implied by the operation and the sibling set, which fits the 'implied usage' bar of 3, but nothing steers the agent between this and e.g. vector_dot_product.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the return envelope on success and on error, which is real behavioral value given no output schema exists. However, it says nothing about edge cases such as ragged or non-numeric input, so the disclosure is only partial.

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 docstring is front-loaded with the purpose, then Args, Returns, and a worked example, with no filler sentences. It is slightly redundant in restating the matrix argument in prose, but every block serves a 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?

For a one-parameter pure function with no output schema and no annotations, the description supplies the input format, the success/error response shape, and a concrete example. Only the handling of malformed input is left unstated, which is a minor gap 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%, so the description must compensate; it does describe the single parameter as "a list of lists", which matches the schema's array-of-arrays-of-numbers type. That is a marginal clarification rather than added semantics (e.g., no rectangularity or dimension constraints), so it lands at the baseline.

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

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

"Transposes a matrix." gives a specific verb and resource, and the operation is unambiguously distinct from siblings like matrix_addition, matrix_multiplication, and matrix_determinant. No sibling tool overlaps with transposition, so the agent can route without ambiguity.

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?

There is no explicit statement of when to use this tool versus the other matrix/vector siblings, nor any prerequisites or exclusions. Usage is implied by the highly self-descriptive name and single-purpose operation, which is the minimum viable level.

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, and it does disclose the success response shape and error shape, which is genuinely useful. However, it says nothing about edge cases such as empty lists, non-numeric input, or how the mean handles large inputs, leaving behavioral gaps.

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

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

The description is well-structured and front-loaded with the purpose, followed by Args, Returns, and two short examples. It is appropriately sized; the second example is slightly redundant but harmless.

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 single-parameter math operation with no output schema, the description covers input meaning, return format, and error format, which is nearly everything an agent needs to invoke it correctly. Missing edge-case behavior keeps it from 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%, but the single parameter is named and explained as 'a list of numerical values,' which matches the schema's array-of-number type. This adds little beyond the schema itself, so a baseline 3 is appropriate for one well-typed 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 states a specific verb and resource: 'Computes the mean of a list of numbers.' It is unambiguous what operation is performed, though it does not differentiate itself from close siblings such as median, variance, or standard_deviation, which it could easily be confused with.

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?

There is no guidance on when to use this tool versus the many related statistical siblings (median, variance, standard_deviation, summation). No conditions, prerequisites, or exclusions are given; the agent must infer that a list of numbers is required input.

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

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

No annotations are provided, so the description carries the full behavioral burden. It helpfully discloses the return shape for success and error, and the example shows even-length median behavior. It does not document edge cases such as empty input, non-numeric values, or ordering assumptions, so the disclosure is only partial.

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 appropriately sized for a simple math utility and front-loads the core purpose. Args, Returns, and a compact example each add practical value, though the Args section is somewhat redundant with the schema and could be tighter.

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 one-parameter pure computation tool with no output schema, the description supplies the essential call signature, return format, and an example. It is minimally sufficient, but it omits edge-case behavior that an agent might need to invoke the tool confidently, such as empty-list handling or ordering expectations.

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 for the undocumented parameter. It says only that data is a list of numerical values, which mostly repeats the schema type (array of numbers) and adds no constraints such as non-empty input, sorting requirements, or handling of null/NaN values.

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

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

The description states a specific verb and resource: it computes the median of a list of numbers. This clearly distinguishes it from close siblings like mean, variance, and standard_deviation by naming the exact statistical measure. However, it does not explicitly contrast itself with those alternatives, so it falls short of the top score.

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 says what the tool does but gives no guidance about when to use median instead of mean or another central-tendency tool. There are no conditions, exclusions, or alternatives named, leaving the agent to infer usage from the tool name alone.

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 and does reasonably well: it documents the return shape ({'result': ...}), the error shape ({'error': ...}), and a concrete failure case for empty input. It omits tie-handling semantics (e.g., multimodal lists return the smallest value, as shown by [1,1,2,2] -> 1.0), which is a notable undocumented behavior, but overall it discloses solid behavioral 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?

Front-loaded with a one-line purpose, then Args/Returns/Examples in a clean docstring layout. Nothing is padded — the examples, including the error case, each earn their place by clarifying concrete behavior.

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?

There is no output schema, so the description correctly compensates by specifying both success and error return shapes. For a simple single-parameter function with no annotations, it supplies everything an agent needs to call it and interpret the result.

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 explain the single parameter — which it does: 'data: A list of numerical values.' This adds the semantic constraint (numerical values) beyond the bare array schema. The examples further clarify accepted input forms, including the empty-list edge 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?

States a specific verb and resource: 'Computes the mode of a list of numbers.' This is unambiguous and clearly distinct from statistical siblings like mean, median, and variance. It doesn't explicitly reference those siblings, but the operation name alone is enough to route correctly.

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 but no guidance on when to use mode versus the many sibling statistics tools (mean, median, variance, etc.). No conditions, prerequisites, or alternatives are mentioned, so the agent must infer selection on its own.

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 and largely does so: it discloses the success payload shape ({result, format: png}), the error payload shape, and expression-syntax rules. It does not disclose limits (e.g., discontinuity handling, valid ranges, or failure conditions for malformed expressions), which keeps it from a 5.

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

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

Front-loads the purpose in one sentence, then organizes Args/Returns/Notes cleanly. The Notes on variable naming and multiplication are useful rather than filler, though the section structure adds slight verbosity.

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

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

No output schema exists, but the description supplies return and error shapes, and the notes cover expression syntax pitfalls. Complete enough to invoke correctly; only edge-case behavior (invalid domains, sampling limits) is unaddressed.

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 — and it does, defining each of the four parameters. Notably it clarifies that 'step' means the number of x samples to render rather than a step size, resolving a genuine naming ambiguity that the schema alone would not.

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?

States a specific verb and resource ('Plots a graph of y = f(x)'), which is clear and unambiguous. It does not explicitly distinguish itself from plotting-adjacent siblings like solve_equation, differentiate, or integrate, but the operation is distinct enough that an agent can route correctly.

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 versus alternatives such as solve_equation or calculate, and no prerequisites or limitations stated. Usage is only implied by the argument list, which is insufficient for a math-plotting tool amid many numeric siblings.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it discloses the return shape ({"solutions": [...]}) and the error shape ({"error": ...}), and pins down input-format rules (explicit '*', 'x' variable, '**' or '^' for powers). It does not mention edge cases such as no-solution or infinite-solution equations, which would complete the picture.

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

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

Well front-loaded with purpose first, then args/returns/examples/notes. The structure is clean and each section is useful, though the third example ("x = 0") is near-trivial and some examples restate the format rules already given in Notes.

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 one-parameter computational tool with no annotations and no output schema, the description supplies everything needed: input format, output format, error format, and worked examples. An agent can call it correctly without opening the schema.

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

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

Schema coverage is 0%, so the description must define the single parameter, and it does thoroughly: the string format, three concrete examples, and the syntax gotchas (x vs x^2, '2*x' not '2x'). This is exactly the compensation a 0%-coverage schema requires.

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?

States a specific verb (solves) and resource (algebraic equation), plus the output contract (returns all solutions). It is clearly distinguishable from compute siblings like differentiate, integrate, and factorize, and the 'for x' scope narrows it further.

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 gives real usage constraints (exactly one '=', must use variable x, SymPy-supported equation classes), which implicitly tells the agent when the tool applies. However, it never names an alternative or says when NOT to use it versus siblings like calculate or expand, so routing is left to inference.

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 and does fairly well: it documents the return shape ({"result": ...}) and the error shape ({"error": ...}). The worked example with [1, 2, 3, 4] -> 1.118... implicitly disambiguates the crucial sample-vs-population convention (this is sample stdev, ddof=1). It stops short of stating edge-case behavior for empty or single-element lists.

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

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

Front-loaded summary sentence followed by compact Args/Returns/Examples sections; the structure is skimmable and each section adds information. Slightly heavier than necessary for a one-parameter function but nothing is wasted.

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

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

No output schema exists, so the Returns block and example are doing necessary work and are present. For a simple unary math function the description is nearly self-sufficient; only the sample-vs-population convention (implied, not stated) and edge-case handling remain implicit.

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, and it does: "data: A list of numerical values" clarifies the element type and constraint that the bare schema (array of number, title "Data") does not spell out. One parameter, adequately described.

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?

States a specific verb+resource ("Computes the standard deviation of a list of numbers"), matching the tool name exactly and making the operation unambiguous. However, it never differentiates itself from close siblings such as variance or mean, which an agent could plausibly confuse for this statistical 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?

No when-to-use guidance is given: nothing explains when to pick standard_deviation over variance, mean, or median, nor any preconditions on the input. Usage is only inferable from the mathematical name itself.

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, and it does disclose the success shape {'result': ...} and the error shape {'error': ...}, which is real behavioral value. It does not address precision, numeric vs symbolic evaluation, or any limits/validation on the expression string (e.g. whether arbitrary code is evaluated), which is a notable gap for a tool taking an expression string.

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

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

Front-loaded purpose sentence followed by clean Args/Returns/Examples sections; nothing is redundant. The section headers are slightly verbose relative to the tiny surface, keeping it short of a 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?

There is no output schema, but the description supplies the return dictionary shape for both success and error plus a concrete example, which is what an agent needs to interpret results. Only minor gaps (defaults, precision or validation behavior on the expression string) 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 description coverage is 0%, so the description must compensate and it does: it documents all three parameters, clarifying that expression is 'the expression of function x as a string' and defining start and end as the summation bounds. This is meaningfully more than the bare schema titles, though it doesn't state that start/end default to 0 and 10.

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?

States a specific verb and resource ('Calculates the summation of a function from start to end'), which is clearly distinguishable from continuous siblings like integrate. However, it does not explicitly contrast itself with any sibling tool, so the agent must infer that this is the discrete counterpart to integrate.

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 the signature and the worked example, which show exactly how to call it. There is no explicit statement of when to prefer this over integrate, calculate, or solve_equation, nor any prerequisites or exclusions.

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

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

With no annotations, the description carries the full burden, and it does disclose the success and error response shapes, which is genuinely useful. It omits important behavioral details for a statistics tool: whether this is sample or population variance, and what happens for an empty list or non-numeric input.

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 purpose is front-loaded in the first sentence, and the Args/Returns/Examples block is compact and skimmable. The boilerplate section headers are slightly heavy for a one-parameter tool but nothing is wasted.

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?

There is no output schema, but the description compensates by documenting the return payload for both success and error cases. The only meaningful gap is the undefined sample-vs-population semantics, which an agent needs in order to trust the result.

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%, but the single parameter is documented in the description as 'A list of numerical values,' which adds meaning beyond the bare array-of-number schema. With only one self-evident parameter, this is adequate.

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 a specific verb and resource ('Computes the variance of a list of numbers'), which is unambiguous. It does not, however, explicitly differentiate itself from close siblings such as standard_deviation, mean, or median, leaving that inference to the agent.

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?

There is no when-to-use guidance and no mention of alternatives, even though standard_deviation and mean are obvious near-neighbors in the sibling list. The worked example implies basic invocation but provides no selection 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?

No annotations exist, so the description carries the full behavioral burden. It does disclose the return shape on success and error plus a worked example, which is meaningful; however, it omits what happens with mismatched dimensions or non-2D/3D inputs and whether a 2D cross product yields a scalar or a 3-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 docstring structure (purpose, Args, Returns, Examples) is front-loaded and each section earns its place. The example adds concrete value rather than padding, though the Args/Returns scaffolding is slightly verbose for a two-parameter math function.

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

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

With no annotations and no output schema, the description covers the essentials (inputs, return shape, error shape, example). It still leaves edge-case behavior – dimension mismatch, 2D result form – undefined, which matters for a function whose valid input space is explicitly restricted to 2D or 3D.

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%, so the description must compensate, and it does document both parameters as 'a list of numbers.' That is minimal, though – it adds no constraints on element count, matching dimensions between vector_a and vector_b, or numeric type beyond what the schema already says.

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 gives a specific verb ('Computes') and resource ('cross product of two 2D or 3D vectors'), which is unambiguous and distinguishable from siblings like vector_dot_product or vector_magnitude by operation name. It does not explicitly name an alternative sibling, but the operation itself is self-differentiating.

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 when-to-use, when-not-to-use, or alternative-selection guidance is offered. The only implicit guidance is the '2D or 3D' dimension constraint, which is really input validation rather than usage routing.

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 present, the description carries the full burden and does reasonably well: it discloses the success shape ({"result": scalar}), the error shape ({"error": message}), the equal-length precondition, and supplies a worked example. It does not state what specifically triggers the error case (e.g., mismatched lengths) or behavior for empty vectors.

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

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

Front-loaded one-line summary followed by Args, Returns, and a runnable example — every section earns its place and there is no filler. Especially valuable given there is no output schema, making the Returns block necessary rather than redundant.

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 two-parameter pure function with no annotations and no output schema, the description covers purpose, inputs, return value, error path, and an example. The only gaps are edge-case semantics (mismatched lengths, empty vectors) and the absence of any cross-reference to sibling vector 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?

Schema description coverage is 0%, so the description must compensate, and it documents both parameters as lists of numbers. That exceeds the schema's bare names/types, though it adds no constraints beyond 'equal length' and no examples of parameter values (the example shows them only inside a combined call).

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 names a precise operation on a specific resource ('dot product of two equal-length vectors'), and the equal-length constraint adds real information. It never differentiates itself from siblings like vector_cross_product or vector_magnitude, so an agent relying on the text alone must infer the distinction from the names.

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 only implied by the mathematical semantics — there is no explicit guidance on when to choose the dot product over vector_cross_product or vector_magnitude. For a pure, unambiguous math operation this is tolerable, but no alternatives or conditions are 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, the description carries the full burden, and it does disclose the result shape ('{result: <scalar magnitude>}') and the error contract ('{error: <error message>}') plus a worked example. It omits any note on edge cases like empty vectors or non-numeric input, so it is strong but not exhaustive.

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

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

Front-loads the one-line purpose, then cleanly separates Args, Returns, and an example. The docstring convention is slightly verbose but every section carries information, with no filler 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?

There is no output schema, so the Returns section is genuinely needed and present, including the error path, and the example confirms the output form. Coverage is good for a one-parameter tool, though edge-case input behavior remains unspecified.

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%, but the single parameter's type (array of numbers) is already fully expressed in the schema. The description's 'A vector as a list of numbers' essentially restates that, adding no format, dimensionality, or validation detail beyond structured data.

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?

States a specific verb and resource ('Computes the magnitude of a vector'), making it unambiguous among siblings like vector_dot_product and vector_cross_product. It does not explicitly name or contrast those siblings, so it falls short of a 5.

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?

There is no explicit when-to-use or when-not-to-use guidance, nor any named alternative. For a pure single-purpose math function the intended usage is implied by the definition itself, which matches a 3 rather than a 4 or 5.

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