MatrixCalculator.net

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior. The description goes further by disclosing input formats and the return shape (exact sum matrix plus a per-position calculation), which the annotations do not cover.

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 sentences, no filler. The core operation and dimension constraint are front-loaded, followed by accepted formats and the return shape.

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, the description commendably states what is returned. It covers the input constraint and formats; only the failure mode for mismatched dimensions is left unstated.

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

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

Schema coverage is 100% and both params have descriptions, so the baseline is 3. The description adds real meaning beyond the schema: accepted value formats (integers, decimals, fraction strings like 1/2) and the equal-dimensions requirement, which the schema does not enforce.

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?

Specific verb+resource ('Add two matrices') with the key constraint ('of the same dimensions entry by entry'). 'Add' naturally contrasts with the subtract/multiply siblings, so an agent can distinguish it without opening 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?

'Useful for exact matrix addition or explaining each entry step by step' gestures at when to use it, but is largely restating the purpose rather than naming conditions or alternatives among matrix_subtract/matrix_multiply. Usage is implied, not spelled 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 already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's added value is the exactness guarantee ('fraction-preserving elimination') and the disclosure that output includes both the determinant and detailed operation steps. It does not mention behavior on non-square or malformed input, which is the remaining gap.

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 sentences, front-loaded with the core action, followed by use cases and return content. The middle sentence is a somewhat padded feature list, but nothing is seriously wasteful.

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, the description correctly compensates by describing the return value (determinant plus operation steps). For a single-parameter, annotated, read-only computation the definition is nearly complete; only error/edge-case behavior 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?

Only one parameter, and schema description coverage is 100% with the schema stating 'Square matrix.' The description repeats the same constraint ('square matrix') without adding format or element-type detail (e.g. strings accepted for exact fractions). With the schema doing the heavy lifting, 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 ('Find the exact determinant') and resource ('square matrix'), plus the technique used ('fraction-preserving elimination'). No sibling (add, inverse, multiply, subtract, transpose) computes a determinant, so the agent can route unambiguously 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?

The 'Use for determinant questions requiring row swaps, elimination steps, pivot multipliers, sign changes, diagonal products, or singularity checks' clause gives concrete invocation context. However, it enumerates sub-features rather than naming alternatives or stating exclusions; the routing benefit comes mostly from the non-overlapping sibling set rather than from explicit 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 declare readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds real value beyond that by disclosing the return contract: the inverse plus verification, or null with singular=true when the matrix is not invertible.

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 sentences, front-loaded with the core action and method, then usage, then return behavior. The middle enumeration of Gauss-Jordan steps is slightly dense but every clause carries information; nothing is padding.

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, the description carries the return-value burden and does so fully: it names the inverse, the verification, and the singular fallback. Combined with the annotations, an agent has enough to call and interpret 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?

There is a single parameter with 100% schema description coverage, so the schema already documents it. The description restates the "square" constraint but adds no format details (e.g. whether strings accept fractions like "1/3"), so it stays at the baseline.

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

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

States a specific verb and resource ("Find an exact inverse of a square matrix") plus the method (Gauss-Jordan elimination), which clearly separates it from the calculator-style siblings matrix_multiply, matrix_determinant, and matrix_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 "Use for inverse questions needing..." sentence gives concrete triggers (exact fractions, augmented matrices, row swaps, verification). It offers no explicit exclusions or alternative routing, but the sibling tools perform entirely different operations, so there is little ambiguity to resolve.

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=false, so safety is covered. The description adds genuinely useful context beyond that: the return payload includes factor pairs, products, and per-entry calculations, and inputs accept fractions as well as decimals. With no output schema present, this return-value disclosure is the value-add.

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 sentences, front-loaded with the operation and its precondition, then output shape, then input flexibility. The middle clause about 'step-by-step row-by-column dot products' is mildly redundant with the return-value sentence but still adds usage framing rather than noise.

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 math tool with no output schema, the description supplies the precondition, the accepted input formats, and the shape of the returned result, which is what an agent needs. It omits nothing critical, though it does not mention limits on matrix size or performance.

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 and the schema already documents matrixA and matrixB. The description goes beyond it by clarifying that numeric entries may be passed as fractions or decimals, which is not evident from the string|number union in 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?

States a specific verb+resource (multiply matrix A by matrix B) and immediately scopes it with the compatibility rule (A's columns must equal B's rows). The operation is unambiguously distinct from sibling tools like matrix_add, matrix_transpose, and matrix_determinant, so an agent can select it without opening a 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?

Gives a concrete precondition for use (column count of A equals row count of B) and clarifies that non-square matrices are supported, which is the main ambiguity for a multiply tool. It does not, however, explicitly route the agent away from or toward any named sibling, so it falls short of a 5.

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

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

Annotations already declare readOnly, idempotent, and non-destructive, lowering the burden. The description adds genuinely new behavior beyond them: precise arithmetic semantics ("exact difference"), accepted input grammar (integers, decimals, fraction strings), and the shape of the return ("each exact difference and its calculation"). Error behavior on a dimension mismatch is still undisclosed.

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 tight sentences with the operation and its precondition front-loaded, followed by accepted inputs and return format. No filler or restated name/title.

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, the description usefully covers what is returned and what inputs are accepted, and it states the dimension-match requirement. It stops short of describing failure behavior when dimensions differ, which is the only meaningful remaining gap for such a simple tool.

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

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

Schema coverage is 100%, so the baseline would be 3. The description earns above baseline by clarifying the otherwise ambiguous union type 'string|number' — the string branch means fraction strings — and by tying both parameters to the same-dimension constraint.

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?

Specific verb+resource ("Subtract matrix B from matrix A") with an explicit precondition. The operation is clearly distinguishable from matrix_add, matrix_multiply, and matrix_transpose by the verb itself, though no sibling is named to reinforce the distinction.

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 states a real usage precondition ("when both have the same dimensions"), which governs when this call is valid. However, it names no alternative tool and gives no guidance on what to do for non-conforming inputs, so usage is only implied.

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=false, so safety is covered structurally. The description adds real behavioral value beyond that: it preserves exact integer/decimal/fraction inputs and returns source-to-result position mappings, which is useful 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?

Three tight sentences with the core operation front-loaded and no filler. The third sentence is a bit long but each clause (type preservation, return shape) carries distinct 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 simple one-parameter, read-only tool with no output schema, the description covers operation, accepted shapes, input-type preservation, and the return structure including position mappings. Nothing an agent needs in order to call it correctly appears to be 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?

With a single parameter at 100% schema description coverage, the schema already documents 'matrix' fully, so the baseline is 3. The description adds only 'rectangular or square', a minor hint that non-square inputs are accepted, but no format or element-typing detail 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 gives a specific verb+resource ('Transpose ... matrix') and clarifies the mechanism ('exchanging rows and columns'), which unambiguously separates it from siblings like matrix_add or matrix_multiply. It does not name a sibling or a disambiguation condition, so it falls short of the top tier.

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?

'Useful for requests to show where each result entry originated' is an implied usage context rather than explicit when/when-not guidance. No alternative tool or prerequisite is mentioned, leaving the agent to infer selection from the operation name.

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