Aman-Amith-Shastry-scientific_computation_mcp

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

Annotations already establish readOnly, idempotent, non-destructive behavior. The description adds context beyond this by stating it operates on stored tensors by name and by documenting ValueError conditions for missing names or incompatible shapes. It does not contradict annotations.

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

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

The docstring is compact and well-structured with Args, Returns, and Raises sections. The phrase 'computing name_a + name_b' is mildly redundant after 'element-wise,' but the overall structure is clean and front-loaded.

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

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

For a simple two-parameter, read-only tensor operation with an output schema and full annotations, the description covers the operation, error conditions, and result type. Nothing an agent needs to call it correctly 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%, with both parameters described as 'name of the first/second stored tensor.' The description's Args section repeats essentially the same information and adds no new semantic detail, so the baseline score 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 ('Adds'), a resource ('stored tensors'), and clarifies the operation is element-wise with 'computing name_a + name_b.' This distinguishes it from matrix multiplication siblings like multiply_matrices, and the operation is unambiguous against subtract/multiply siblings.

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

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

The description implies usage—call this when you need element-wise addition of two stored tensors—but it provides no explicit when-to-use vs alternatives, no exclusions, and no mention of sibling tools like subtract_matrices or multiply_matrices. The Raises section hints at constraints but doesn't help an agent select among operations.

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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful behavior: it returns a new Tensor representation and raises ValueError for missing or non-invertible matrices, going beyond the structured annotations.

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

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

The description is compact and well-structured with Args, Returns, and Raises sections. Every line conveys useful information without fluff or redundant elaboration.

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

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

Given the two simple parameters, full schema coverage, an output schema, and annotations, the description is largely complete for invoking the tool. It includes error conditions and return semantics, though it could clarify the mathematical convention for interpreting new_basis columns.

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 parameters are already well documented. The description mostly restates the schema ('Name of the matrix in the tensor store', 'Columns are new basis vectors') and adds only minor context, not significant new meaning.

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 uses a specific verb and resource: 'Changes the basis of a stored square matrix.' This clearly distinguishes it from sibling tools like determinant, matrix_inverse, or qr_decompose, which perform different operations.

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

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

The intended context is implied: use this when you have a stored square matrix and want it re-expressed in a new basis. However, it provides no explicit guidance about when to prefer this tool over related alternatives, nor does it mention any excluded cases.

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

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

The description adds meaningful behavioral detail beyond the annotations: it specifies the return dict with eigenvalues and right eigenvectors, and explicitly documents ValueError for non-square or missing tensors. No contradiction with readOnlyHint/idempotentHint.

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 well-structured with Args, Returns, and Raises sectionshots, and the core behavior is front-loaded. It is slightly repetitive with the schema, but not enough to hurt clarity.

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

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

For a single-parameter read-only analysis tool, the description fully covers input requirements, return shape, and failure modes. The agent has everything needed to invoke 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?

The schema already describes the single parameter as the name of the stored square matrix. The docstring's Args section largely restates this, adding minimal new semantic value.

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

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

The description opens with 'Computes the eigenvalues and right eigenvectors of a stored square matrix' — a specific verb, clear target resource, and immediate distinction from sibling matrix tools like SVD, QR, or inverse.

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 is given on when to use this tool instead of sibling tools, and no alternative tools are named. The square-matrix constraint is stated, but not developed into selection guidance 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?

Annotations already declare readOnlyHint=false and idempotentHint=true. The description adds the ValueError condition for mismatched values and specifies the return format as nested lists, which are useful behavioral details beyond annotations. No contradiction exists.

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

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

The description is well-structured with Args, Returns, and Raises sections, and is front-loaded with the core purpose. It avoids excessive detail while including important error handling information.

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

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

The tool is simple and the description covers purpose and error conditions. However, it does not specify behavior when a tensor with the same name already exists (overwrite vs. error), which could be relevant for an agent. Given the output schema and annotations, this is a minor but notable gap.

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

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

Schema coverage is 100% with descriptive text for each parameter. The description's Args section merely repeats parameter names without adding new semantics. It even inaccurately describes shape as a 'tuple' while the schema expects a list, which could cause minor confusion.

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

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

The description clearly states the tool creates a NumPy array with specified shape and values, and stores it under a given name. This is specific and distinct from sibling operations like add_matrices or view_tensor, which operate on existing tensors.

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

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

The description implies usage for creating tensors to be referenced by other tools via the name parameter, as reinforced by the schema description for name. It doesn't explicitly list alternatives or exclusions, but the context is clear given the tool's purpose.

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 readOnly, idempotent, and non-destructive behavior, so the description only needs to add behavioral context. It adds that the curl is computed symbolically by default and can be numerically evaluated at a point, plus the return format is a dict with a string and optionally a numeric vector. This goes beyond the annotation coverage and gives useful insight.

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 first sentence is an effective, front-loaded purpose. The Args/Returns sections mirror the schema, which introduces minor redundancy, but the structure is clean and the text remains short. It could be trimmed to remove duplication, but overall it is well-organized.

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

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

Given the limited 2-param schema, full schema descriptions, and readOnly/idempotent hints from annotations, this description is sufficient. It mentions the symbolic versus numeric behavior, the Return dict, and doesn't need to explain return types because the output schema exists. There are no missing pieces for correct calling.

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

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

The input schema fully describes both parameters (coverage 100%), with the same explanations for f_str and point that appear in the description. The description repeats those semantics but adds no new meaning beyond the schema, so it stays at the baseline 3.

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 symbolic curl of a vector field' – and clearly distinguishes this from the other vector calculus siblings (divergence, gradient, laplacian). It also mentions the optional numeric evaluation, which helps an agent understand the tool's unique capability.

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

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

The description implies when to use the tool (whenever a curl of a vector field is needed), but it gives no explicit routing to alternatives such as divergence or gradient. An agent can infer usage from the purpose, but there is no explicit 'use this instead of' 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?

Annotation Contradiction: The description says ValueError is raised if the tensor name is not found, implying a second delete of the same name fails. This contradicts the idempotentHint=true annotation, which claims repeated identical requests produce the same outcome. Additionally, the description adds little beyond annotations: the destructive behavior is already declared, and 'if an error occurs during deletion' is vague.

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

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

The description is compact and front-loaded with the core purpose. The structured Args/Returns/Raises format is easy to parse. Minor redundancy exists because the Args section repeats schema information, and the 'or if an error occurs during deletion' clause is imprecise, but overall it is efficient.

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 deletion tool, the description covers the action, parameter, return value, and error condition. However, the idempotency contradiction creates meaningful ambiguity about repeated calls, and the description does not clarify irreversibility beyond the annotation. The output schema and annotations fill many gaps, but the contradiction undermines completeness.

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

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

Schema description coverage is 100%, so the schema fully documents the required 'name' parameter. The description repeats the parameter meaning but adds no extra format, constraints, or edge-case details beyond what the schema provides. 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?

The description states a specific verb and resource: 'Deletes a tensor from the in-memory tensor store.' This clearly distinguishes it from sibling tools like create_tensor, view_tensor, and matrix operations. It also names the target store, leaving no ambiguity about what the operation affects.

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 context is clear: use this tool to remove a named tensor from the in-memory store. However, it does not explicitly mention when not to use it or name alternatives such as create_tensor or view_tensor. The usage context is strong but exclusions are absent.

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 mark it as read-only and idempotenthjklmn, but the description adds specific behavior: it raises ValueError when the matrix is not found or not square. That error handling detail goes beyond the structured annotations and is valuable for an agent.

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

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

The description is compact and front-loaded with the core purpose, followed by a standard Args/Returns/Raises block. Every sentence earns its place; no filler or redundant phrasing.

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 read-only operation, the description covers purpose, input, return type, and failure conditions. The presence of an output schema and existing sibling list makes this complete; no critical operating detail 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?

The input schema already fully describes `name` as 'Name of the stored square matrix,' and the description restates this almost identically without extra depth (e.g., no naming conventions, accepted formats, or reference requirements). Schema coverage is 100%, so the description adds little beyond the schema.

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

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

The description clearly states the action ('Computes'), the specific object ('determinant'), the input domain ('stored square matrix'), and the return type. This unambiguously differentiates it from siblings like matrix_inverse or transpose.

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 strongly implies when to use this tool (when you need a matrix's determinant) and includes error conditions, but it does not explicitly contrast with alternative tools or state when not to use it. This is clear context without explicit exclusions or named sibling alternatives.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds the unit normalization default (unit=True) and that the result is a symbolic string, which are helpful behavioral details beyond annotations. It does not discuss limitations like variable assumptions or error handling, but these are minor 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?

The description is compact, with clear docstring-like structure. It front-loads the main purpose, then lists parameters and return. Every sentence is informative, though the parameter listings partially mirror the schema, which is slightly redundant but not verbose.

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

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

Given the tool's moderate complexity, the output schema exists to describe return values, and the description covers the key inputs and behavior. It lacks deeper context like supported variable names or edge cases (e.g., zero vector), but for a symbolic math tool, the description is adequate. No major missing details for correct invocation.

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

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

Schema coverage is 100%, so each parameter is already documented. The description adds the example expression "x*y*z" and the default for unit, but these are mostly redundant with schema descriptions. It does clarify that u is a direction vector and unit controls normalization, which aligns with schema. No significant additional meaning beyond schema.

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

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

The description clearly states it computes the symbolic directional derivative of a scalar field along a vector direction, specifying the math operation and the resource (scalar field). This distinguishes it from siblings like gradient, divergence, and curl, which are different vector calculus operations.

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

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

The description implies use for directional derivative calculations in vector calculus contexts; however, it does not explicitly state when to prefer this over siblings like gradient or when not to use it. The context of the tool name and the operation are clear enough for an agent to select it appropriately.

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 read-only, idempotent, non-destructive behavior. The description adds that the result is symbolic and optionally numerically evaluated at a point, but does not discuss errors, expression constraints, or exact return shape beyond 'dict'.

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?

Concise, front-loaded with the core operation; the example and point-evaluation detail are relevant without bloat.

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?

Together with annotations and schema, the description covers what the tool computes, the string format, and the optional numerical evaluation. It does not specify key names in the returned dict or error/edge cases, but the output schema likely supplies that.

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 already covers f_str and point with 100% parameter coverage. The description adds an example string and the optional evaluation semantics, which is helpful but not a major semantic layer beyond the schema.

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

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

The description states a specific operation ('computes the symbolic divergence of a vector field') with a clear subject, input domain, and an optional numeric-evaluation behavior. No ambiguity about what the tool does.

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 clearly defines the computation but gives no guidance on when to choose it over closely related sibling tools like curl or gradient, nor conditions for using the optional point parameter. Context is implied by the operation itself, not by explicit selection 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?

Annotations already carry readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuine value beyond annotations by disclosing the ValueError failure modes (matrix not found, decomposition fails) and the expected return format. No contradiction with the annotations exists.

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

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

The definition is compact and front-loaded with the core purpose. The Args/Returns sections are somewhat redundant with the schema and output schema, but the Raises section adds unique value. It is efficient without being over-redundant, though the Args block could be trimmed.

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

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

With the output schema present, return format need not be spelled out in prose, and annotations cover safety. The description covers purpose, algorithm, and failure modes for the single parameter. It is essentially complete for a simple read-only tool; only alternative-routing guidance is absent.

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 schema's parameter description ('Name of the stored matrix whose column space to orthogonalize.') is actually richer than the description's own 'name (str): The name of the matrix.' Since the schema already documents the single parameter fully, the description adds no additional semantics, warranting the baseline of 3.

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 ('finds'), a precise target ('orthonormal basis for the column space of a stored matrix'), and the method ('using QR decomposition'). This clearly differentiates it from the sibling `qr_decompose` (returns the factor pair) and `change_basis` (changes to an arbitrary basis), even without reading their schemas.

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 purpose is clear and the algorithm hint implies the use case (you want an orthogonalized column-space basis). However, there is no explicit guidance on when to choose this over `qr_decompose` or `change_basis`, and no exclusions or alternative conditions are stated, so the agent must infer the 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful context that the computation is symbolic and returns a string representation of a vector, but it does not disclose potential failure modes, input restrictions beyond 'scalar function,' or behavior on invalid expressions. No contradiction with annotations.

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

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

The description is appropriately short and front-loaded with the main purpose. The Args and Returns sections are standard and add structure without excessive detail. It loses a point for repeating schema information that didn't need restating.

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 symbolic math tool, the description is mostly complete: it names the operation, the expected input form, and the output form. Since an output schema is present, the return type does not need further explanation. Minor gaps include lack of mention of variable names beyond the schema and no guidance on error handling, but these are not critical.

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

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

Schema description coverage is 100%, so the schema already documents f_str as a scalar function of x, y, z with an example. The description repeats this information in the Args section without adding meaning beyond the schema. It gives an example, but the schema already provides the same one.

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 symbolic gradient of a scalar function.' The return type is also clear. It does not explicitly distinguish itself from related siblings like curl, divergence, or directional_deriv, but the mathematical meaning of gradient is well established and the scalar-function input helps disambiguate.

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

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

The description provides no guidance on when to use this tool versus siblings such as curl, divergence, or directional_deriv. There is no mention of alternatives, exclusions, or context that would help an agent decide that gradient is the right choice among the many vector calculus tools.

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

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

Annotations already cover read-only and idempotent hints. The description adds value by disclosing the return format (string, scalar or list of 3 components) and noting the symbolic nature of the result. It does not contradict annotations, and the added behavioral context is helpful.

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

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

The description is a compact docstring with a clear structure: purpose, Args, Returns. Every sentence adds information—no filler. The key purpose is stated first, and the parameter/return details are neatly organized.

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 symbolic math tool, the description is complete: it explains inputs, the scalar/vector distinction, and the output format. With annotations covering safety and an output schema present (though not shown), nothing essential is missing for an agent to call 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 coverage is 100% with both parameters described. The description reinforces the parameter meanings with concrete examples (e.g., 'x**2 + y*z' and '[Fx, Fy, Fz]') and clarifies the effect of is_vector on the computation. While it largely repeats schema info, the examples add practical clarity beyond the schema.

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

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

The description clearly states the tool computes the Laplacian of a scalar or vector field symbolically, with explicit examples of input formats. It distinguishes itself from sibling vector calculus tools (gradient, curl, divergence) by its specific operation, making the purpose 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 clear context for when to use it (computing Laplacians) and explains the scalar vs. vector distinction via the is_vector flag. It does not explicitly name alternatives or exclusions, but the purpose is so specific that usage is implied. A 4 reflects clear context without explicit exclusionary 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?

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds meaningful behavioral context by specifying failure conditions: missing matrix, non-square matrix, and singular/non-invertible matrix.

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

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

The description is compact and well-structured with Args, Returns, and Raises sections. Every sentence is informative, with no redundancy or unnecessary filler.

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

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

For a single-parameter tool with an output schema and safety annotations, the description is complete. It documents the key constraints (square, invertible) and error conditions, leaving no important invocation requirements 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 100%, and the description's 'Args' section essentially restates the schema. It does not add meaningful parameter semantics beyond what the schema already provides.

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

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

The description clearly states the tool computes the inverse of a stored square matrix, with a specific verb and resource. It does not explicitly distinguish itself from sibling tools, though the operation is unique among the listed siblings.

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 context for use is implied: an agent would call this when it needs the inverse of a stored square matrix. However, the description does not explicitly state when to use this tool over alternatives or when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds valuable behavioral context: it raises ValueError if tensors are not found or shapes are incompatible, and returns a Tensor. This goes beyond annotations and helps the agent anticipate failure conditions.

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

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

The description is a concise docstring with clear sections (Args, Returns, Raises). The main operation is stated first, and each section is minimal and relevant. No wasted words; the structure is ideal for an agent to parse quickly.

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

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

The description covers the essential context: operation, parameters, return type, and error conditions. Since an output schema exists, the description doesn't need to detail the return structure. It might mention storage semantics ('stored tensors') but is otherwise complete for a straightforward matrix multiplication tool. A 4 reflects a minor omission—no mention of how to obtain tensor names or if any preconditions exist—but these are likely covered by sibling tools and context.

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

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

Schema coverage is 100%, and both parameters (name_a and name_b) are already described in the schema. The description simply restates them without adding new meaning (e.g., format, constraints, or usage nuances). Baseline of 3 is correct because the schema carries the semantic load.

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: 'Performs matrix multiplication between two stored tensors'. It clearly differentiates from siblings like add_matrices and subtract_matrices by explicitly naming the operation (name_a @ name_b). No ambiguity about what the tool does.

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 clearly implies when to use this tool (when matrix multiplication is needed) and the operation is self-contained. However, it does not explicitly mention alternatives or exclusion criteria (e.g., 'for element-wise multiplication use...'). Since the purpose is unambiguous and siblings are distinct, this is a minor gap, so a 4 is 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?

Annotations already mark it readOnly and non-destructive. The description adds useful behavioral detail beyond that: it auto-selects between a 2D line plot and a 3D surface based on whether the expression contains x only or both x and y, and it returns a rendered Matplotlib Image.

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 an Args/Returns breakdown, includes concrete expression examples, and front-loads the core purpose. Every sentence contributes useful information.

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

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

For a plotting tool with annotations covering safety, the definition explains the input expression form, axis ranges, grid resolution, return type, and automatic 2D/3D behavior. It lacks explicit failure-mode information and contains the ylim discrepancy, so it is not fully complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds examples and explains the variable-based dimensionality switch, but it conflicts with the schema on ylim: the description says it is 'used in 2D or 3D' while the schema says 'used only for 3D surfaces.' This inconsistency prevents a higher score.

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

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

The description opens with a specific verb and resource: 'Plots a 2D or 3D mathematical function from a symbolic expression string.' This clearly distinguishes the tool from sibling plot_vector_field, which handles vector fields rather than scalar functions.

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

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

The description provides clear context for when to use the tool—plotting symbolic mathematical expressions in one or two variables—and conveys the 2D vs. 3D behavior. It does not explicitly name alternatives or state when not to use it, but the intent is unambiguous given the sibling set.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds useful behavioral detail: the tool displays a Matplotlib 3D quiver plot and does not return an image. This goes beyond what the annotations provide without contradicting them.

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

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

Compact docstring with a clear one-sentence purpose, an Args list, and a Returns note. No unnecessary prose, though the Args section is partially redundant with the schema's parameter descriptions.

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 read-only plotting tool, the description covers the input format, grid resolution, bounds, and return behavior (displayed plot, no image return). All essential information for calling it correctly is present; error handling of malformed strings is not described but is not critical for basic use.

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

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

Schema description coverage is 100% and the schema already explains each parameter (f_str format, bounds tuple, n resolution). The description's Args section restates these but adds no new information beyond the schema, so the baseline score 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 ('Plots') and resource ('3D vector field'), and includes an example expression. Clearly distinguishes itself from siblings like plot_function, which presumably handles scalar functions, by emphasizing the 3D vector field input.

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 first sentence gives clear context for when to use this tool: when a 3D vector field needs to be visualized. It does not explicitly name alternatives or exclusion criteria, but the purpose statement is specific enough to guide selection.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by specifying the return format (keys 'q' and 'r' as nested lists) and raising ValueError for missing matrices or decomposition failure, which goes beyond the annotations.

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

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

The description is well-structured with a clear summary, mathematical definition, args section, returns section, and raises section. Every sentence earns its place, and the core purpose is front-loaded. It is appropriately sized for a tool with one parameter and a defined output.

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

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

The description is complete for a single-parameter read-only tool: it explains the operation, the return structure, and error conditions. The output schema exists, so return values are already structured. It could mention prerequisites (e.g., matrix must be square) but the ValueError for decomposition failure covers the failure mode adequately.

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

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

Schema description coverage is 100%, so the schema already documents the 'name' parameter as 'Name of the stored matrix to decompose.' The description repeats this information without adding new semantic detail, such as expected matrix format or constraints. Baseline 3 is appropriate since the schema carries the parameter documentation burden.

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

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

The description clearly states the tool computes the QR decomposition of a stored matrix, specifies the mathematical relationship A = Q @ R, and defines Q as orthogonal and R as upper triangular. This distinguishes it from siblings like svd_decompose, determinant, and matrix_inverse, which perform different matrix operations.

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

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

The description implies usage context: it operates on a stored matrix identified by name, and the mathematical definition makes clear it is for QR factorization. It does not explicitly state when to prefer this over svd_decompose or other decompositions, but the mathematical clarity and sibling context provide adequate 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, read-only operation. The description adds a ValueError if the tensor name is not found, which is useful behavioral context beyond what annotations provide. However, it does not detail how the rank is computed for tensors with different dimensionalities (e.g., matrix vs. higher-order tensor), which could be a behavioral nuance. Given annotations cover safety, a 3 is appropriate.

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

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

The description is concise and well-structured: a one-line summary, clear Args, Returns, and Raises sections. It is front-loaded with the main action, and every sentence adds value—there is no filler. This is an example of effective brevity.

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

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

The tool has one parameter, a rich output schema (int | list[int]), and clear annotations. The description covers the essential usage: it names the parameter, describes the return type, and notes the error condition. A slight gap is not specifying whether the rank can be multi-valued (list[int]) for higher-order tensors, but the output schema covers that. Given the simplicity and available structured data, the description is sufficiently complete.

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

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

Schema description coverage is 100% since the only parameter 'name' is described in the schema as 'Name of the stored tensor'. The description repeats this with 'The name of the tensor' and adds the context that it must exist in the store (via the Raises section). This adds minimal value beyond the schema but is not harmful. Baseline is 3, and it is met.

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

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

The description clearly states the verb 'computes' and the resource 'rank of a stored tensor', which is specific and distinguishes it from sibling tools like determinant or svd_decompose. It is not just a tautology of the name 'rank' because it clarifies that it operates on tensors in the store. However, it could better differentiate from related concepts like shape or dimensions, but the purpose is clear.

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

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

The description implies when to use this tool: when you need the rank of a stored tensor and have its name. However, it does not explicitly state when not to use it or mention alternatives (e.g., use 'view_tensor' to inspect the tensor itself). The context is clear but lacks exclusions or comparisons to siblings.

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

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

Beyond the annotations, the description discloses important behavior: the default in_place=True mutates the stored tensor, in_place=False returns a new tensor and leaves storage untouched, and a missing name raises ValueError. No contradiction with the annotations is present.

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

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

The purpose sentence is front-loaded and the docstring is compact and well organized. The Args/Returns/Raises sections are mostly redundant with the schema, but the description still remains appropriately sized.

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 tool with full schema coverage, an output schema, and annotations, the description covers the core operation, mutation versus non-mutation behavior, and the error case. Nothing necessary for correct invocation 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%, so the baseline is 3. The Args section essentially restates the schema's parameter descriptions without adding meaningful new details about formats, edge cases, or usage constraints.

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

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

The description opens with 'Scales a stored tensor by a scalar factor,' which names a specific verb, the resource, and the exact operation. This clearly distinguishes it from sibling tools like add_matrices or multiply_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 implies when to use this tool: to scale a stored tensor by a scalar, with the in_place flag deciding mutation versus returning a new tensor. However, it does not explicitly mention alternatives or state when another sibling tool should be used instead.

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, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the error condition (ValueError for missing names or incompatible shapes), which is useful behavioral context beyond the annotations. However, it doesn't disclose details like whether the result is stored or returned transiently, or any side effects on the stored tensors.

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

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

The description is compact and front-loaded with the core operation in the first sentence. The Args/Returns/Raises sections are standard and add necessary detail without bloat. It earns a 4 because it is efficient, though the Args section largely duplicates the schema.

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

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

The tool is simple (2 params, no nested objects) and has an output schema, so the description doesn't need to explain return values. The error conditions are disclosed, and the operation is fully specified. It is complete for an agent to call correctly, though it could mention whether the result is stored or returned.

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

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

Schema description coverage is 100%, so the schema already documents both parameters fully. The description repeats the parameter meanings ('minuend' and 'subtrahend') but adds no new semantic information beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description states a specific verb ('subtracts'), a specific resource ('stored tensor'), and the exact operation ('computing name_a - name_b'). It clearly distinguishes itself from siblings like add_matrices and multiply_matrices by naming the element-wise subtraction operation.

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

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

The description implies usage by defining the two tensor names and the operation, but it does not explicitly state when to use this tool versus alternatives like add_matrices or multiply_matrices. The context is clear enough for an agent to infer the use case, but there is no explicit when/when-not guidance.

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

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

Annotations already mark the operation read-only, idempotent, and non-destructive, and the description adds meaningful behavioral detail: it specifies the returned keys and raises ValueError when the matrix is missing or decomposition fails. This adds value without contradicting the annotations.

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

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

The description is compact, front-loads the defining formula, and clearly partitions Args/Returns/Raises. Some redundancy with the schema and output schema exists in the Args and Returns sections, but it remains well-structured and the extra error information is useful.

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, read-only, idempotent tool with an output schema, the description covers the operation, mathematical definition, return keys, and failure mode. An agent has everything it needs to select and invoke the tool correctly.

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

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

The input schema already documents the single 'name' parameter at 100% coverage, and the description's Args section essentially restates 'matrix to decompose'. No additional parameter semantics are provided beyond the schema, so the baseline of 3 is appropriate.

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

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

The description states the specific verb 'Computes' and the exact resource 'stored matrix', and defines the operation with the formula A = U @ S @ V^T plus characteristic output keys. This makes it unmistakably distinct from sibling matrix tools such as qr_decompose or compute_eigen, even without naming them.

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 makes clear that this tool is for computing the SVD of a stored matrix, which gives an agent a clear condition for when to call it. It does not explicitly discuss alternatives or when not to use it, so it stops short of the top score.

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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds beyond that by stating the return value is the transposed tensor and by documenting the ValueError when the tensor name is not found.

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

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

The description is a tight docstring with a one-sentence summary plus compact Args, Returns, and Raises sections. Every part earns its place and there is no filler or redundant prose.

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, non-mutating operation backed by annotations, an output schema, and a documented failure mode, the description is largely complete. It does not specify exact transpose behavior for higher-dimensional tensors, but the low complexity and standard meaning make this a minor gap.

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

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

Schema description coverage is 100%, so the schema already fully documents the single 'name' parameter. The description repeats the parameter's meaning with 'The name of the tensor to transpose' but does not add new constraints, formats, or edge-case guidance.

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

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

The description opens with 'Computes the transpose of a stored tensor,' giving a specific verb and resource. This clearly distinguishes it from sibling operations like matrix_inverse, determinant, and view_tensor without needing to open the 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?

The description clearly establishes the context: it operates on a stored tensor and requires the tensor's name. It does not explicitly list exclusions or alternative tools, but the operation is unique enough among siblings that the usage context is clear.

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

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

Annotations provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the tool is known to be safe and non-destructive. The description adds value by mentioning the operation's non-commutative nature implicitly through operand ordering (name_a vs name_b) but does not explicitly state that cross product is anti-commutative, which is relevant behavior. It also mentions the error condition (ValueError) but that provides minimal extra beyond schema. Overall, since annotations cover safety, the description adds moderate value with error handling details.

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

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

The description is concise with a clear purpose statement, parameter descriptions, return type, and error conditions. It follows a docstring format that is well-structured: purpose first, then args, returns, and raises. No extraneous information. Each sentence earns its place.

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

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

Given the tool complexity (mathematical operation on stored vectors), the description is a bit sparse. It lacks critical usage details such as vector dimensions required (cross product typically only for 3D), dimensionality constraints, and what happens if the vectors are not 3D. While the output schema exists (though not provided in full), the description doesn't explain return format beyond 'Tensor'. Considering the sibling tools are all mathematical operations, more context on applicability would improve completeness.

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

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

Schema description coverage is 100% with clear descriptions for both parameters: each is 'Name of the first/second stored vector' and left/right operand. The description adds minimal value, essentially repeating the same information. However, it does clarify that the tool operates on stored vectors (by name), which is slightly beyond schema. Baseline 3 is appropriate as the schema already covers parameter meaning.

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

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

The description clearly states that the tool computes the cross product of two stored vectors, specifying the operands as name references in the tensor store. It distinguishes from siblings like vector_dot_product and vector_project by explicitly naming 'cross product'. However, it doesn't explicitly differentiate from other vector operations, but the verb 'cross product' is specific enough.

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

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

The description implies usage: it requires two vectors stored in the tensor store)Skip, but does not explicitly state when to use this tool versus alternatives (e.g., for 3D vectors only, not for dot product). It doesn't mention constraints like vector dimensionality (cross product is typically only defined for 3D vectors), which is a notable gap for correct usage.

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 mark this readOnly and idempotent, lowering the burden. The description adds that a ValueError is raised when a vector is missing or the operation fails, and that inputs are stored vectors referenced by name, which is useful behavior beyond annotations. No contradiction.

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

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

Three short sections: a one-line computation statement, two parameter lines, return and error note. No filler, and the Raises clause is behaviorally useful. The description is compact and structured for quick scanning.

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 compute tool, the description covers operation, operands, return, and failure mode. It doesn't mention vector dimension compatibility or that vectors must already be stored, but schema param titles ('stored vector') plus 'stored vectors' in the description cover this. An agent has sufficient context to invoke correctly.

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

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

Schema coverage is 100% and both parameters are named and described in the schema. The description repeats the same parameter explanations, adding no extra semantic nuance beyond 'stored' vectors. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: 'Computes the dot product between two stored vectors.' This clearly distinguishes it from sibling tools like vector_cross_product and vector_project 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?

The description makes the tool's purpose clear (computing a dot product between two stored vectors), so an agent can infer when to use it. However, it does not explicitly state exclusions or alternatives (e.g., when to prefer cross product or projection), leaving some selection reasoning 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, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds value by specifying error behavior (ValueError if name not found or projection fails) and the return type (Tensor), which goes beyond the structured annotations.

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

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

The description is a single concise sentence plus a structured Args/Returns/Raises block. It is front-loaded with the main purpose and avoids unnecessary elaboration. However, the Args block largely duplicates the schema, making it slightly redundant, but overall it remains tight and efficient.

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

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

The tool is simple, and the description, combined with the output schema, provides sufficient information for an agent to call it correctly. It covers the main inputs, the return type, and an error condition. While it does not mention dimension matching or prerequisites for the stored vector, such details are likely implied and not critical for a straightforward projection 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%, so both parameters are already documented in the schema. The description's Args section repeats the schema text ('Name of the stored vector to project' and 'The vector to project onto, as a flat list') without adding new semantic details such as vector dimension requirements or format expectations. Thus it adds no significant value beyond the schema.

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

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

The description states a specific action: 'Projects a stored vector onto another vector.' It clearly identifies the resource (stored vector) and the operation (projection), which distinguishes it from sibling operations like add, multiply, or determinant.

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

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

The description explains what the tool does but does not provide explicit guidance on when to use it versus alternatives. It neither names sibling tools nor gives conditions for selection. The usage context is implied by the operation but not clarified.

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?

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses important runtime behavior: the returned value is an immutable view, it is returned as nested lists, and it raises ValueError when the name is missing. This gives the agent a clear model of what happens on both success and failure.

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 Args, Returns, and Raises sections, making it easy to parse. It is concise, though there is slight redundancy between 'previously stored' and 'as stored in the in-store dictionary'.

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 tool with full annotations and an output schema, the description covers the essential details: what it returns, where the data lives, and the failure mode. Nothing critical is missing for an agent 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 coverage is 100%, so the parameter is already well-documented by the schema. The description adds minor context by clarifying that the name is used as the key 'as stored in the in-store dictionary', but this does not substantially change an agent's understanding beyond the schema.

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

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

The description clearly identifies the verb ('Returns'), resource ('previously stored NumPy tensor'), and source ('in-memory tensor store'). It distinguishes this as a read-only retrieval tool relative to mutation siblings like create_tensor and delete_tensor, though it doesn't explicitly name 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?

The phrase 'previously stored' implies the tool should be used after a tensor has been created, and the ValueError note indicates a precondition that the name must exist. However, there is no explicit statement about when to choose this tool over siblings or when not to use it.

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