calculator

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

No annotations are provided, so the description carries full responsibility for behavioral transparency. It only says 'run a calculation' and mentions results + URL, but does not disclose side effects, session requirements, or how the URL is generated. Essential behavioral context is missing.

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 primary action. It is concise with no wasted words, achieving a strong structure.

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 incomplete given the tool's context. With sibling tools like create_session and push_session_action, it likely requires a session but this is not mentioned. There is no output schema, and the description does not explain the return format or relationship to the prefilled URL. The agent receives insufficient context to use the tool correctly in a broader workflow.

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 does not add meaningful parameter-level details beyond what the schema already provides, such as the meaning of 'calculator slug' or 'inputs' structure. It earns the baseline but no more.

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 ('Run') and resource ('calculation') and clearly states the outcome ('results + prefilled URL'). However, it does not distinguish itself from sibling tools like calculate_cas or generate_prefilled_url, so it lacks explicit 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?

The description offers no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or conditions, leaving the agent without direction for tool 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?

With no annotations, the description carries the burden and does disclose an important behavior: unsupported expressions return a GUI handoff link. It also adds context like 'headless', 'server-side', and 'MCP-only numeric mode', but does not mention success output format, error handling, or session/state behavior, leaving gaps for a mutation-capable 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 exactly two sentences, front-loading the core purpose and adding the unsupported-expression behavior in the second sentence. No words are wasted, making it highly concise and well-structured.

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 with parameter descriptions, but there is no output schema to clarify the return structure. The description explains the unsupported case (GUI handoff link) but not what a successful evaluation returns, leaving incomplete guidance for agents expecting numeric results. The sibling ambiguity also detracts from 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?

All three parameters (strict, expression, expressions) have descriptions in the schema, so schema coverage is 100%. The description's mention of 'one or more' aligns with the expression vs expressions distinction but adds no additional meaning beyond the schema, justifying the baseline score 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 clearly states the tool evaluates headless CAS expressions server-side, with a specific verb and resource. It mentions 'MCP-only numeric mode' to distinguish from GUI calculators, but does not explicitly differentiate from the sibling tool 'calculate_cas_headless', so it falls short of a 5.

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

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

The description implies usage for headless server-side numeric evaluation via MCP, and notes that unsupported expressions return a GUI handoff link. However, it does not explicitly state when to use this tool over alternative siblings like 'calculate' or 'calculate_cas_headless', so guidance is 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?

With no annotations provided, the description carries the behavioral burden. It reveals a non-obvious fallback behavior (returning GUI handoff details for unsupported features), which is useful. However, it does not mention side effects, read-only status, error handling, or other behavioral traits.

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 front-loads the alias relationship and then states the core function. It is concise with no padding, though 'Alias of calculate_cas' is partly redundant given 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?

For a 3-parameter tool with full schema documentation and no output schema, the description gives basic context but omits details like return structure or how 'GUI handoff details' appear. It is adequate for a simple evaluator but leaves some gaps for an AI agent.

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 100% of parameters, so the baseline is 3. The description adds no parameter-specific details; the schema already explains strict, expression, and expressions. No additional semantic value is provided.

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 identifies the tool as a 'Headless MCP-only CAS evaluator' and an alias of calculate_cas, making the core purpose clear. It differentiates from siblings by emphasizing the headless MCP-only nature, though the action verb is implied ('evaluator') rather than explicit.

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 in MCP-only/headless contexts and mentions fallback to GUI handoff details, but does not explicitly state when to use this over calculate_cas or other siblings. The alias reference gives some context, but there are no clear exclusions or alternative recommendations.

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 discloses the optional snapshot persistence, which is a key behavioral trait. However, with no annotations, it does not mention the destructiveness of closing (e.g., irreversibility, whether the session becomes invalid) or any expected return behavior. It provides basic transparency but leaves room for more.

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 that packs the core action and an optional variant. No unnecessary words, front-loaded with the verb 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?

For a simple tool with one parameter, the description is adequate but lacks details about return values, edge cases (e.g., closing an already-closed session), or post-conditions. No output schema or annotations exist, so the description could have offered more context, but the tool's simplicity keeps the score at a passing level.

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

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

The schema fully describes the single parameter (session_id as Session UUID), so the description adds no extra meaning. With 100% schema coverage, the baseline of 3 is appropriate; the description does not need to compensate.

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 adds an optional behavior: 'persist a snapshot of its final state'. It distinguishes itself from sibling tools like create_session (opposite) and get_session_state (read-only), making the tool's purpose unmistakable.

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 (closing a session) but does not explicitly state when to use it versus alternatives, such as retrieving state before closing or whether there are prerequisites. No exclusions or alternative recommendations are provided.

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 mentions returning a session URL but does not disclose potential side effects, resource consumption, session lifecycles, or the need to close sessions later. This is a meaningful gap for a resource-creating 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 a single, front-loaded sentence with no filler. It conveys the action, target, and result efficiently, earning a top score for conciseness without sacrificing key 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?

While the schema covers parameters, the description lacks important session lifecycle context: it does not mention that sessions should be closed with 'close_session', that they can be interacted with via 'push_session_action', or what 'interactive session' entails relative to the sibling tools. This leaves the agent without a complete operational picture.

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 provides descriptions for both parameters ('Calculator slug' and 'Optional session metadata'), and schema coverage is 100%. The description adds little beyond 'any calculator', so the baseline of 3 is appropriate; the schema handles the parameter semantics adequately.

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 ('Create') and resource ('interactive session') and clearly states the output (session URL). It distinguishes from siblings like 'calculate' (one-off calculations) and 'close_session' (destructive), making the purpose unmistakable.

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

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

The description does not explain when to choose this tool over alternatives, such as 'calculate' (which might not require a session) or how sessions relate to 'push_session_action' and 'close_session'. No contextual guidance or alternatives are mentioned, leaving the agent to infer usage from the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only notes that no calculation is run, but omits side effects, permissions, or whether the tool modifies any state. This is too little for a tool that could have side effects.

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

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

The description is a single, front-loaded sentence with zero wasted words. It fully captures the essential behavior and distinction in a compact form.

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 three parameters (including a nested object) and no output schema. The description omits what the generated URL looks like, any encoding behavior, or return format, making it incomplete for a tool that produces a URL.

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 schema already describes all parameters. The description adds no extra parameter meaning, but the baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description uses a specific verb and resource ('Generate a prefilled URL') and adds a key qualifier ('without running calculation'). This clearly distinguishes it from sibling tools like 'calculate' and 'calculate_cas' that perform actual calculations.

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 the tool is for when a calculation is not yet desired, offering clear context. However, it does not explicitly name alternative tools or state when to use this over them.

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 disclosing behavior. It states 'Get the input schema' which implies a read-only operation, but it does not explicitly confirm safety, mention authentication requirements, side effects, or error conditions. The description adds minimal behavioral context beyond the action itself.

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, focused sentence that is front-loaded with the verb and object. It contains no filler or redundant information, making it appropriately concise for a simple schema retrieval 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?

Given the low complexity (one parameter, no output schema, no annotations), the description is adequate but not fully complete. It does not mention that the returned schema is in JSON format, how the calculator slug relates to list_calculators, or any prerequisites. Sibling tool names provide some context, but the description could offer more operational guidance.

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 has one parameter 'calculator' with description 'Calculator slug', providing 100% schema description coverage. The description's phrase 'specific calculator' mirrors the parameter meaning without adding additional syntax, format, or source information. The baseline of 3 is appropriate since the schema already documents the parameter adequately.

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 'Get' and identifies the resource 'input schema' with a qualifier 'for a specific calculator'. This clearly distinguishes the tool from siblings like list_calculators (which lists calculators) and calculate (which performs calculations). The purpose is unambiguous.

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

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

The description does not explicitly state when to use this tool versus alternatives. However, the purpose implies usage: one would fetch a calculator's schema before invoking it. No exclusions or alternative tool references are given, so it relies on the agent's inference from the sibling tool names.

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 are absent, so the description must carry the burden of disclosing side effects and safety. The verb 'Retrieve' suggests a read-only operation, but the description does not explicitly state that it is non-mutating or explain what happens to the pending message queue (e.g., whether it is consumed or remains). It also does not address error conditions (e.g., session not found) or authorization requirements. This lack of behavioral disclosure is a 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?

The description is a single, well-formed sentence that front-loads the action ('Retrieve') and lists the three components of the result. It contains no redundant or unnecessary words, making it appropriately concise and structured.

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 retrieval tool without an output schema, the description is fairly complete: it specifies the required session context (active) and exactly what will be returned. However, it could be more complete by mentioning the return format or potential error states, but given the simplicity of the tool, this level of detail is sufficient.

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% (the only parameter, session_id, is fully described as 'Session UUID'). The tool description does not add any additional meaning beyond the schema, so the baseline of 3 is appropriate; the description simply says 'for an active session', which aligns with the parameter semantics without expanding on format or 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 clearly states the verb 'Retrieve' and the specific resources: current field values, computation transcript, and pending message queue for an active session. This is specific enough to distinguish it from siblings like 'push_session_action' (which modifies) or 'get_calculator_schema' (which retrieves schema, not 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 usage: use this tool when you need to inspect a session's current state. However, it does not explicitly mention alternatives or when not to use it (e.g., comparing with 'calculate' or 'push_session_action'). There is no exclusionary guidance, but the purpose is clear enough to infer appropriate use.

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

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

No annotations are provided, so the description carries the full burden. It only states the action and optional filter, without disclosing read-only nature, return format, or any side effects. Minimal behavioral context is added beyond the bare listing.

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, front-loaded with the verb and resource, and contains no waste. Every word contributes meaning.

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 listing tool with one optional parameter and no output schema, the description is adequate. It lacks details on what 'available' means or the return structure, but given the low complexity and schema coverage, it 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?

The schema already describes the 'category' parameter with examples ('finance', 'math') and indicates it is optional. The description adds the word 'optionally' which matches schema, but offers no additional semantic value beyond what the schema provides, so 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 uses the specific verb 'List' and identifies the resource as 'available calculators', with an optional category filter. It clearly distinguishes this from sibling tools like calculate_cas 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 description implies usage through its verb and optional filter, but does not explicitly state when to use this tool versus alternatives or provide exclusions. There is no discussion of when not to use it or reference to 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?

The phrase 'message queue' hints at asynchronous processing, but the description provides no detail on ordering, execution semantics, error handling, or side effects. With no annotations, the description carries the full burden of behavioral disclosure, and it only offers a one-line summary. This is insufficient for a tool that mutates session state.

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 that communicates the core function with zero filler. It efficiently uses examples to convey breadth without enumerating every action. This is 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?

The tool has a complex actions array with many possible action types, yet the description only lists a handful of examples and gives no information about return values, ordering, or how it fits with the session lifecycle. The schema covers parameter semantics but not the operational context, and there is no output schema. The description is too sparse to fully orient an agent.

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 has 100% description coverage for all parameters, including detailed descriptions for each action property. The description itself references example action types but adds no new meaning beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The description uses the specific verb 'push' and identifies the resource 'a session's message queue', which clearly states the tool's action. It lists representative actions ('set fields, submit computation, trigger plot') that indicate the tool's scope and distinguish it from sibling tools like calculate or get_session_state. This is a clear and specific purpose statement.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like calculate_cas or get_session_state. The examples imply it is the mechanism for sending various actions to a session, but it does not state exclusions or prerequisites. Usage is only implicitly conveyed.

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