MCPCalc

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It reveals the core action and outputs (results and URL), but does not disclose whether the operation is read-only, how strict mode affects execution, error handling, or any side effects. The minimal transparency is insufficient for a tool with this complexity.

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 sentence that is front-loaded with the action and output. It is concise and every word contributes meaning, avoiding unnecessary details. However, it is under-specified, which prevents a perfect score.

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?

Without annotations or an output schema, and with only a one-sentence description, the tool's return format, error behavior, and usage context are unclear. The presence of multiple similar sibling tools (calculate_cas, calculate_cas_headless, generate_prefilled_url) further highlights the missing guidance on when this tool is appropriate.

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 descriptions for all three parameters (calculator slug, inputs, strict), so the baseline is 3. The description's mention of 'prefilled URL' hints that the inputs parameter also influences URL generation, adding slight context beyond the schema, but this is not enough to raise the score above 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?

The description clearly states the tool's action ('Run a calculation') and its distinctive output ('results + prefilled URL'). It distinguishes from siblings by mentioning the prefilled URL, but it doesn't explicitly differentiate from calculate_cas or generate_prefilled_url, so it's clear but not fully differentiating.

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

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

The description provides no guidance on when to use this tool versus alternatives like calculate_cas or generate_prefilled_url. The mention of 'prefilled URL' implies a use case, but there are no exclusions, prerequisites, or comparative context, leaving the agent without decision support.

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

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

With no annotations, the description carries the burden of disclosing behavior. It usefully states that unsupported expressions return a GUI handoff link and that it is headless/server-side. However, it does not mention potential side effects on session state (given the session-oriented sibling tools) or any error/edge-case behavior beyond the handoff link.

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 sentence that is front-loaded with the action and resource, then adds a key behavioral note. There is no redundancy or filler; every part contributes to understanding the tool.

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

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

The tool is simple with good parameter schema coverage, but the description lacks enough context to fully understand its role among overlapping siblings. It reveals the handoff link behavior but does not explain return format, prerequisites, or how 'numeric mode' impacts usage. Without an output schema, more explanation would be beneficial.

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 descriptions for all three parameters, so the baseline is 3. The description adds the notion of 'one or more' but does not provide additional meaning or examples beyond what the schema already offers, so it neither substantially enhances nor detracts.

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 evaluates headless CAS expressions server-side, specifying the verb ('evaluate') and resource ('one or more headless CAS expressions'). It includes scope ('MCP-only numeric mode'), but does not explicitly distinguish from the similarly named sibling tool 'calculate_cas_headless', so it misses full differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives like 'calculate' or 'calculate_cas_headless'. The description mentions 'MCP-only numeric mode' but does not explain why an agent would choose this over other calculation tools or when to avoid 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?

With no annotations, the description carries the burden. It discloses headless, MCP-only nature and GUI handoff behavior for unsupported features, adding useful context. However, it does not mention side effects, permission requirements, or what a normal successful response looks like.

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 (two clauses separated by a semicolon) and front-loaded with the core function and alias. Every sentence earns its place, though 'Alias of calculate_cas' is somewhat redundant with the tool name.

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

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

The tool has no output schema, so the description must explain return values. It only mentions GUI handoff for unsupported features, not what a successful evaluation returns. It also does not explain parameter interactions (e.g., expression vs expressions) or when to use one over the other.

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 baseline 3 applies. The description adds no additional meaning about parameters beyond the schema descriptions; it does not clarify expression syntax, strict mode behavior, or how expression and expressions relate.

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?

Description clearly states it is a 'Headless MCP-only CAS evaluator,' indicating the tool evaluates CAS expressions. It also identifies as an alias of calculate_cas, providing differentiation from sibling tools like calculate and session management tools, though the alias reference is indirect.

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

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

No explicit guidance on when to use this tool vs alternatives. The alias reference implies interchangeability with calculate_cas, and the GUI handoff note hints at limitations, but there is no clear 'when to use' or 'when not to use' direction.

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

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

With no annotations, the description carries the full burden. It mentions an optional snapshot but doesn't explain how it is triggered or what happens to the session (e.g., destructiveness, reversibility, side effects). This leaves important behavioral context 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?

A single sentence with clear focus. It is front-loaded and avoids unnecessary words, earning 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?

Low complexity (one param) but no output schema and no annotations. The description does not explain return values, side effects, or prerequisites, and the optional snapshot is not elaborated, leaving major gaps for a tool that likely has destructive impact.

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% (session_id described as 'Session UUID'), so the baseline is 3. The description adds no extra meaning to the parameter and even references an option not represented 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?

The description clearly states the action ('Close a session') and the resource, and the optional snapshot persistence adds specificity. It distinguishes itself from siblings like create_session and get_session_state.

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 it (when you want to end a session) but provides no explicit exclusions or alternatives. The optional snapshot persistence hints at a decision point but doesn't say when to choose it.

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

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

No annotations provided, so description must disclose side effects. It implies creating a session but doesn't state resource lifetime, authentication requirements, or failure modes. No mention that sessions are interactive and must be closed with close_session.

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?

Single sentence, direct, front-loaded with verb and object. No unnecessary words.

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

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

No output schema, so description should detail return format. It only says 'session URL' without specifying structure. No mention of how to use the URL or whether calculator must be valid. Sibling tools like list_calculators and close_session indicate related context 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 covers both parameters with descriptions, so baseline is 3. Description adds no additional parameter meaning beyond the schema's 'Calculator slug' and 'Optional session metadata'.

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 'create', resource 'interactive session', and outcome 'session URL'. Clearly distinct from sibling tools like calculate or close_session.

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

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

No guidance on when to use this tool vs alternatives like calculate_cas or generate_prefilled_url. No mention of prerequisites such as needing an existing calculator.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states a negative behavior ('without running calculation') and does not mention side effects, prerequisites, return format, or validation behavior. The 'strict' parameter behavior is only explained in the schema, not the description.

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, front-loaded sentence with no filler. Every word earns its place, clearly stating the action and the key differentiator ('without running calculation'). This is exemplary conciseness.

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

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

Given the tool has no output schema and no annotations, the description should explain what the returned URL looks like and when to use the tool. It only provides a minimal statement. The nested 'inputs' object and 'strict' parameter are not contextualized. The description is too sparse for a tool with this complexity, leaving agents without enough information to invoke it confidently.

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 description adds no additional parameter information beyond the schema, and the schema's descriptions are adequate for the params (calculator slug, input values, strict flag). No extra semantics are needed.

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

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

The description clearly states the tool's purpose: 'Generate a prefilled URL' with the explicit qualifier 'without running calculation'. This distinguishes it from sibling calculation tools like calculate and calculate_cas. The verb 'generate' is specific and the resource 'prefilled URL' is well-defined in context.

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 'without running calculation' implies a use case distinct from the calculate siblings, but it does not explicitly state when to use this tool vs alternatives. No exclusions or prerequisites are mentioned, so guidance is only implied rather than explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'get' implies a read-only operation, but the description does not explicitly state it is non-destructive, nor does it disclose potential errors or effects of invalid input. It provides minimal but acceptable transparency for a simple getter.

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, clear, front-loaded sentence with no wasted words. It directly states the action and target, achieving excellent conciseness.

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

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

Given the tool's simplicity (one parameter, no output schema, no nested objects), the description is sufficiently complete. It conveys what the tool returns (input schema) without needing to explain return format. Minor gaps like error handling or prerequisites are not critical for this utility tool.

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

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

The input schema covers the only parameter ('calculator' with description 'Calculator slug') at 100% coverage. The description adds no additional meaning about the parameter beyond what the schema already provides, 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 'Get the input schema for a specific calculator' uses a specific verb ('get') and identifies a clear resource ('input schema' for a calculator). It distinguishes itself from sibling tools like list_calculators (which lists calculators) and calculate (which performs calculations), making its 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?

There is no explicit guidance on when to use this tool versus alternatives. The description simply states what it does without mentioning prerequisites, exclusions, or contrasting with sibling tools. Usage is only implied by the name and description.

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

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

With no annotations, the description carries the burden. 'Retrieve' indicates a read-only operation and the listing of returned components adds some transparency. However, it does not disclose error behavior, authentication requirements, or what happens if the session is inactive.

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, well-structured sentence that directly states the purpose without any wasted words. It front-loads the action and resource.

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 simple one-parameter schema and no output schema, the description sufficiently covers what the tool does and what it returns. It does not detail error conditions, but the core functionality is fully described.

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 covers 100% of the sole parameter (session_id as 'Session UUID'). The description adds no additional semantics beyond the schema, so the 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 clearly states the tool retrieves current field values, computation transcript, and pending message queue for an active session. The verb 'retrieve' and specific resources distinguish it from sibling tools like push_session_action or close_session.

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

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

Usage is implied: use when you need to fetch the state of an active session. There is no explicit mention of when not to use or alternatives, but the context is clear enough for a read-only retrieval tool.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It indicates a read-only 'list' operation but does not state whether it is read-only, what fields are returned, whether pagination exists, or any other behavioral traits. The description adds minimal transparency beyond the tool name.

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 sentence, front-loaded with the primary action, and contains no filler or redundant information. It earns every word.

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 list tool with one optional parameter and no output schema, the description is adequate but incomplete. It fails to specify what the returned list contains (IDs, names, categories) or any pagination/format details, which would be necessary for an agent to use the results effectively.

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 fully describes the 'category' parameter (100% coverage), so the baseline is 3. The description's phrase 'optionally filtered by category' merely restates the schema without adding new meaning or examples 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 states a specific verb ('List') and resource ('available calculators'), and clearly distinguishes from siblings like 'calculate' and 'get_calculator_schema' by focusing on enumeration rather than computation or schema retrieval.

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 usage is implied: to discover available calculators. However, there is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The optional category filter gives some context but no direct comparison with sibling tools.

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

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

With no annotations, the description carries the full burden. It introduces the 'message queue' concept but does not explain whether pushes are asynchronous, whether actions execute in order, or what happens on failure. The return value and error semantics are also omitted.

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

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

A single sentence that is front-loaded and precise. It avoids redundancy and gives enough context without over-explaining.

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 schema is rich and detailed, making the tool usable for constructing actions. However, the description lacks operational guidance about queue behavior, ordering, or error handling, which is important for a tool with such a wide variety of action types and no output schema.

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

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

The input schema already provides 100% coverage with detailed descriptions for both top-level parameters and every nested action property. The description adds only a few action-type examples, which is marginal 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 uses a specific verb ('Push') and resource ('session's message queue') and lists concrete examples ('set fields, submit computation, trigger plot'). This clearly differentiates it from siblings like 'calculate' or 'get_session_state'.

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 provided on when to use this tool versus alternatives. It does not mention that this is for batching multiple actions or when a direct calculation would be preferred. No exclusions or prerequisites are stated.

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