Math MCP Learning

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

Annotations already declare readOnlyHint and idempotentHint, so safety is partly covered, but the description still adds meaningful behavioral context: the word "Safely" signals sandboxed evaluation, and the explicit whitelist of allowed operators and functions tells the agent which expressions will succeed. It stops short of describing error behavior for invalid or out-of-scope expressions.

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 two short capability lists scan quickly. There is mild duplication with the schema's own parameter description, which also enumerates the supported operators and functions, but overall the text is tight and earns its length.

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

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

For a single-parameter, read-only, idempotent tool with a fully described schema and an output schema that covers return values, the description supplies everything needed to invoke it correctly. The only gap is what happens on an unsupported or malformed expression, which is a minor omission.

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

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

Schema description coverage is 100% and the single expression parameter is already well documented there, including an example and the 500-char limit. The description's operator/function list marginally reinforces the schema but adds no syntax or formatting detail beyond it, so the baseline of 3 applies.

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

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

The description gives a clear verb+resource ("evaluate mathematical expressions") plus the supported operator/function surface, so an agent immediately knows this is a general-purpose expression evaluator. It does not, however, explicitly distinguish itself from siblings like calc_interest or calc_statistics, which also perform calculation, so the boundary is only implied.

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 or when-not-to-use guidance and no sibling is named. An agent cannot tell from the text whether this should handle an interest or statistics question that happens to be expressible as a formula, leaving the routing decision 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds the computation formula and the decimal convention for the rate, but says nothing about precision/rounding, handling of extreme inputs, or output format. With annotations carrying the safety burden, 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 purpose is front-loaded in one sentence and the formula plus variable list follow in a scannable structure with no wasted prose. It is slightly longer than strictly necessary for a 4-parameter calculator, but every line contributes to interpretation.

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 an output schema present and read-only/idempotent annotations, the description need not explain return values, and it covers the conceptual model fully. The minor gap is that it never mentions the default monthly compounding or the >0 constraints that the schema enforces.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description goes further by mapping P, r, n, and t onto the formula and clarifying that n is compounds-per-year and r is the decimal annual rate. This ties each input to its role in the computation, adding meaning beyond the individual schema descriptions.

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

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

The description names a specific verb and resource ('Calculate compound interest for investments') and the accompanying formula pins down exactly which computation is performed, making it clearly distinct from generic siblings like calc_expression or calc_statistics. An agent can identify this as the financial/interest-specific calculator without opening any schema.

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 statement of when to use this tool versus alternatives such as calc_expression, nor any exclusions or prerequisites. Usage is only implied by the tool's name and formula, so an agent must infer routing 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds nothing beyond that — it doesn't mention edge cases such as mode returning multiple values, empty input, or the 10,000-element cap. Adequate but not value-adding with annotations present.

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

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

Two short lines, purpose front-loaded in the first sentence and the operation set placed immediately after. Nothing is redundant or padded for a tool of this simplicity.

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

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

With a 100%-covered two-parameter schema and an existing output schema, return values need not be described. The definition is nearly complete; only edge-case behavior for degenerate inputs is unaddressed, which is a minor gap for a pure calculation tool.

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

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

Schema description coverage is 100% and both parameters are documented in the schema with examples and allowed values. The description's operation list merely repeats the enum values already present in the schema, adding no syntax or format detail beyond it. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Perform statistical calculations on a list of numbers') and enumerates the supported operations, so the agent knows exactly what the tool computes. It is distinguishable from calc_expression and the matrix_* siblings by domain, though it never names those alternatives explicitly.

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 operation list and 'on a list of numbers', but there is no explicit when-to-use/when-not guidance or routing to calc_expression for arbitrary expressions. The agent must infer that this tool is for descriptive statistics over an existing numeric array rather than for evaluating formulas.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds no behavioral context beyond that: nothing about case-insensitivity of abbreviations, temperature offset handling, or what happens when from_unit/to_unit are incompatible with unit_type. Useful scope information, but no operational behavior disclosed.

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 and then uses a scannable list. The unit inventory is largely redundant with the schema's per-parameter descriptions, which is mild waste, but the total length is short and the structure is clean.

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 need no explanation, and annotations cover the safety profile. Combined with full parameter documentation, the definition gives an agent everything needed to call it correctly, with only edge-case behavior (mismatched units, temperature offsets) left 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 100%, with each parameter documenting the valid units per unit_type, so the baseline is 3. The description's unit lists and groupings restate what the schema already carries rather than adding constraints such as case sensitivity or invalid-pair behavior.

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 ('Convert between different units of measurement') and immediately enumerates the supported unit families, so the agent knows exactly what domain this covers. The sibling set (calculators, matrix ops, plotting, workspace) contains nothing else unit-related, so disambiguation is immediate.

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 purpose — an agent will reach for this when it needs a dimensional conversion — but there is no explicit when-to-use guidance and no named alternative (e.g. calc_expression for arithmetic on raw numbers). Adequate but leaves routing 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds nothing beyond that: the 'square matrix' requirement is already stated in the schema's parameter description, and there is no note on how non-square or oversized input is handled.

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?

A single front-loaded sentence with zero filler, properly sized for a one-parameter tool. It is efficient, though it leaves no room for the alternative-routing context a fuller definition would include.

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 tool with full schema coverage, an output schema, and safety annotations, the definition covers what an agent needs to invoke correctly. Only input-error behavior (non-square matrices, dimension limits) 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?

There is only one parameter and schema description coverage is 100%, with the schema documenting the nested row structure, example, and maxItems. The description adds no syntax or format detail beyond what the schema already provides, so the baseline 3 applies.

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

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

Names a specific operation (calculate the determinant) on a specific resource (square matrix), which cleanly separates it from siblings like matrix_inverse, matrix_transpose, and matrix_multiply. It does not explicitly name those siblings as alternatives, but the verb+resource pairing is 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 gives no guidance on when to choose this tool over matrix_eigenvalues or matrix_inverse, nor any prerequisite context. It only implies usage from the resource type, with no explicit when/when-not conditions.

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

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

Annotations already declare readOnlyHint and idempotentHint, covering the safety profile. The description adds nothing beyond that: no mention of whether complex eigenvalues are returned, behavior for non-symmetric or ill-conditioned matrices, or computational limits despite the 10000-item cap in the schema.

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?

A single tight sentence with no filler, front-loading the verb and resource. It is efficient, though the brevity edges toward under-specification for a numerical 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?

An output schema exists, so return values need not be explained, and the single required parameter is fully documented in the schema. Still, edge-case behavior (non-square input handling, complex results, large-matrix performance) is absent for what is a nontrivial numerical operation.

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

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

Schema description coverage is 100%, with the 'square matrix' constraint, row layout, and an example already documented in the schema. The description's mention of 'square matrix' merely repeats the schema, so baseline 3 applies.

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

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

States a specific verb (calculate) and resource (eigenvalues of a square matrix), so the operation is unmistakable. However, it offers no differentiation from closely named siblings like matrix_determinant or matrix_inverse, which an agent must disambiguate on its own.

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 versus matrix_determinant, matrix_inverse, or other matrix siblings, nor any note on preconditions such as squareness or numerical limitations. The agent is left to infer selection purely from the 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?

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds the 'square matrix' precondition, but omits critical behavior: what happens for singular/non-invertible matrices, and numerical precision expectations. Adds some value but leaves the main edge case undocumented.

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?

One short sentence with the key constraint ('square') and purpose front-loaded. No filler, nothing to trim.

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?

A simple tool with an output schema (so return-value explanation is unnecessary) and full annotation coverage. Still, for a matrix operation the most important behavior — failure on non-invertible input — is absent, which an agent would need to avoid erroring on user data.

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

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

Schema description coverage is 100% and the single 'matrix' parameter is fully documented in the schema including row orientation and an example. The description's only addition is the 'square' constraint, so it matches the baseline for schema-covered parameters.

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 ('calculate') and resource ('inverse of a square matrix'), which is enough to separate it from siblings like matrix_determinant or matrix_transpose. However, it never names those alternatives, so the differentiation comes from the name rather than the description.

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 and no mention of alternatives such as matrix_determinant (to test invertibility) or matrix_multiply. An agent must infer the use case entirely from the tool 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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. Beyond that the description adds nothing: no dimension-compatibility requirement, no behavior for invalid shapes, no note on size limits (maxItems 10000) or computational cost. The '(A × B)' ordering is the only added 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?

A single front-loaded sentence with zero wasted words. It is grammatically complete, though its terseness borders on under-specification for a tool with real constraints (shape compatibility, size caps).

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 need no explanation, and the operation is simple. Still, the description omits the dimension-compatibility rule that determines whether a call succeeds, which is material for a matrix-multiply tool.

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

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

Schema description coverage is 100% with both parameters documented and exemplified, so the schema carries the load and a 3 is the baseline. The description contributes no extra meaning about matrix_a or matrix_b 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?

States a specific verb and resource ('Multiply two matrices'), which cleanly separates it from matrix_determinant, matrix_inverse, matrix_transpose, and matrix_eigenvalues. However, it never names or references those siblings, so differentiation is implied rather than stated.

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, no prerequisites, no mention of alternatives such as matrix_inverse for solving systems. The only hint is the '(A × B)' notation, which does not tell an agent when this tool is the right pick.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, covering the safety and repeatability profile. The description adds no behavioral context beyond that (no shape constraints, no input validation notes), so it contributes almost nothing beyond the structured fields.

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?

A single, front-loaded sentence with zero filler. Every word 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?

For a trivial pure-math tool with a complete parameter schema and an output schema, the description is sufficient — an agent needs no return-value or permission detail. It could be marginally stronger with an explicit usage cue, but nothing essential is 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?

Schema description coverage is 100% and the single 'matrix' parameter is fully documented in the schema, including an example. The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('Transpose a matrix') and adds the mathematical semantics via the parenthetical 'swap rows and columns'. It is clearly distinguishable from siblings like matrix_multiply or matrix_inverse, though it never names those alternatives.

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 explicit when-to-use or when-not-to-use guidance is given. Usage is only implied by the well-known mathematical meaning of 'transpose', which an agent must infer rather than read.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds one piece of genuine context, the matplotlib dependency ('requires matplotlib'), but says nothing about what is produced or returned (figure, image, file path).

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?

A single front-loaded sentence with no wasted words; the intent and the dependency are both packed in. It is efficient though not rich enough to warrant 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?

For a plotting tool with no output schema and read-only annotations, the description omits the return format (rendered image vs figure object), which is the key unknown an agent faces. Parameters and safety are adequately covered by schema and annotations, so the gap is limited but real.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema with examples. The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

States a specific verb ('Create') and resource ('box plot') plus its analytical intent ('comparing distributions'), which differentiates it from plot_histogram and plot_scatter siblings by chart type. It stops short of explicitly naming which sibling to use instead for other distribution views.

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?

'for comparing distributions' implies when a box plot is appropriate, giving some selection signal against histogram/line siblings. However, there is no explicit when-to-use/when-not guidance or mention of alternatives, leaving routing 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?

Annotations already cover read-only and idempotent behavior, so the bar is lower, and the description still adds genuinely useful context: the matplotlib dependency and the explicit warning that the data is synthetic rather than real. That said, it says nothing about how the chart is delivered (returned inline vs. saved to a file), which matters for a plotting tool with no output schema.

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 short sentences with the core action front-loaded and no filler. The matplotlib caveat is placed parenthetically rather than buried, though the dependency could arguably be its own sentence for scannability.

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 about output, the description should say what the caller receives (image, file path, or data). It covers inputs and the synthetic-data caveat adequately but leaves the return contract entirely 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 100%, so all four parameters (days, color, trend, start_price) are already documented with defaults and examples in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Generate and plot synthetic financial price data') and pins the content domain to financial prices, which separates it from the generic plot_line_chart sibling. It does not explicitly name which sibling to prefer when the data isn't financial, but the domain qualifier does most of the disambiguating work.

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?

Gives implied context ('for educational purposes') and a negative constraint ('does not use real market data'), which tells the agent not to reach for this tool when actual market data is needed. However, it never states when to choose this over plot_line_chart or plot_function, nor any prerequisite beyond the matplotlib note.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds one genuinely useful fact beyond the annotations — the matplotlib dependency — but says nothing about what is returned (image, file, data) or how invalid expressions are handled.

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?

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity shades into under-specification rather than optimal conciseness.

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 description carries the burden of explaining what the tool returns — and it does not say whether the result is an image, a file path, or inline data. Combined with the absence of usage guidance, the definition is not complete enough for an agent to know what to expect from a successful call.

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

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

Schema description coverage is 100%, so expression, x_range, and num_points are fully documented in the schema with examples and bounds. The description adds no additional parameter meaning, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb (Generate) and resource (mathematical function plots), which implicitly separates it from the histogram/scatter/box-plot siblings. However, it never names those siblings or contrasts itself with them, so an agent must infer the distinction from the wording alone.

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 exclusions, and no mention of alternatives such as plot_line_chart or calc_expression. The agent gets no help deciding between this tool and the six other plotting/calculation 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?

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered and the description adds the matplotlib dependency, which is useful environment context. However, it says nothing about what the call produces (figure object, rendered output, file) and there is no output schema to compensate.

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?

A single short sentence with no filler; the core action is front-loaded. It is efficient, though bordering on under-specification rather than being genuinely tight and informative.

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

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

For a three-parameter plotting tool with no output schema, the description should say something about the result (where the histogram is rendered or returned). The matplotlib prerequisite is a helpful start, but the return behavior is left entirely 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 100%, with bins, data, and title all documented with examples in the schema itself. The description adds no parameter detail beyond that, so the baseline 3 applies.

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

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

States a specific verb and resource ('Create statistical histograms'), so an agent knows this bins numeric data into a chart. It does not explicitly differentiate from sibling plotting tools like plot_box_plot or plot_scatter, but the resource noun is 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 parenthetical '(requires matplotlib)' is a dependency note, not usage guidance. There is no statement of when to prefer a histogram over plot_box_plot, plot_line_chart, or plot_scatter, and no conditions or exclusions 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?

The annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description usefully adds that matplotlib is required, a genuine runtime dependency not captured by annotations. It still omits what the tool actually produces (inline image, saved file, or return object), which matters given there is no output schema.

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?

A single front-loaded sentence with no filler or redundancy. It is efficiently sized, though the parenthetical dependency note is the only content beyond a restatement of the 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 7 parameters, no output schema, and annotations covering only safety, the description should clarify the return behavior (image object, file path, or display side effect) and the constraint that x_data and y_data must be equal length. Neither is present, leaving an agent unable to predict the result of the call.

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

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

Schema description coverage is 100%, so every parameter (x_data, y_data, color, labels, grid) is already documented with examples in the schema. The description adds nothing beyond 'data points' and therefore sits at the baseline for schema-documented 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 states a specific verb and resource (create a line chart from data points), which is unambiguous on its own. It does not, however, distinguish itself from close siblings like plot_scatter, plot_function, or plot_financial_line, which an agent would need to choose between.

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 prefer a line chart over plot_scatter, plot_function, or plot_box_plot, nor any mention of prerequisites beyond the matplotlib dependency. The agent must infer selection criteria 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so safety is covered. The description adds one useful piece of context the annotations lack: the matplotlib runtime dependency. It says nothing about output (image object, base64, or file path) or limits on data size, though the 10,000-item caps are visible in the schema.

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?

One sentence, zero filler, and the essential dependency note is included. Nothing could be removed without losing information, and nothing important is buried.

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 7-parameter tool with full schema coverage and safety annotations, the definition is minimally adequate. The notable hole is the return contract: with no output schema, the agent cannot tell whether this returns an image, a file path, or nothing, which matters for a chart-rendering tool.

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

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

Schema description coverage is 100% and every parameter carries an example and default, so the schema does the heavy lifting. The description adds no parameter meaning beyond 'data points', which is the baseline 3 case when the schema is self-sufficient.

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 ('Create a scatter plot from data points'), which is unambiguous on its own. However, it does nothing to distinguish it from the five sibling plot_* tools (plot_line_chart, plot_histogram, plot_box_plot), so an agent choosing between chart types gets no routing help.

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 no when-to-use guidance, no conditions, and no alternatives. With five sibling plotting tools available, the absence of any routing signal (e.g., scatter for correlation between two variables vs line for trends) is a real gap.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered structurally. The description adds only the vague notion of loading 'previously saved' results; it omits error behavior for missing variables, which would be genuinely useful 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?

A single front-loaded sentence with no filler; it does the job efficiently. Slightly clipped phrasing ('calculation result from workspace') keeps it from being an exemplar.

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 need not be explained, and annotations cover the read-only/idempotent profile. The only meaningful gap is the absence of any note about failure when the named variable is not found.

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

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

Schema description coverage is 100% and the single parameter is fully documented with an example in the schema itself. The description adds no format, naming conventions, or lookup semantics beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (load) and resource (previously saved calculation result from workspace), which is clear enough to distinguish it from the sibling workspace_save. It does not, however, explicitly name or contrast with any sibling, 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?

No guidance on when to use this versus alternatives, and no preconditions stated (e.g., that the variable must have been saved first, or what happens if the name does not exist). The word 'previously saved' hints at a precondition but does not spell it out.

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

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

Annotations declare readOnlyHint=false and idempotentHint=false, and the description usefully adds that storage persists across restarts. However, with idempotentHint=false the key unanswered question is what happens when an existing name is reused (overwrite vs. duplicate vs. error) — the description is silent on this, which is the main behavioral risk.

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?

A single short sentence with no waste, front-loading the verb and resource. It is appropriately sized for the tool's simplicity, though brevity comes at the cost of the overwrite behavior noted above.

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-value explanation is not required, and the persistence semantics are covered. The only material omission is collision behavior on an existing variable name, which for a non-idempotent write is worth one more clause.

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

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

Schema description coverage is 100% and all three parameters (name, expression, result) are documented with types, limits and examples in the schema. The description adds no format or constraint detail beyond it, so the baseline 3 applies.

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

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

States a specific verb ("Save") and resource ("calculation to persistent workspace"), and the parenthetical defines the persistence semantics. It is distinguishable from the sibling workspace_load by contrast, though it never names the sibling explicitly.

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 beyond the implied durability of "persistent workspace (survives restarts)". Nothing tells the agent when saving is preferable to just recomputing with calc_expression, or what to do if a calculation shouldn't be persisted.

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