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

Annotations already declare readOnlyHint and idempotentHint, so the tool is known to be safe. The description adds the behavioral directive to call it first, providing context beyond structured annotations. No contradictions.

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 with no wasted words, front-loaded with purpose and immediately providing actionable usage guidance.

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

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

With an output schema available and zero parameters, the description fully covers the tool's purpose and usage, making it complete for an agent to select and 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?

The tool has zero parameters, so the description has no parameter semantics to cover. The baseline of 4 applies as there is nothing to clarify.

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 a specific action ('Discover') and resource ('available API guidance and skills'), distinguishing it from sibling tools like read_skills (which loads guidance) and list_instances (which lists instances).

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?

Explicitly instructs 'Call this FIRST before using other openstaad-mcp tools' and directs to 'read_skills' for loading full guidance, providing clear when-to-use and an alternative.

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 `destructiveHint: true` annotation, the description discloses exactly what the sandbox does: it blocks `import`, `dir()`, and `getattr()`, pre-injects `staad`/`input_data`/`json`/`math`, and returns either the last expression value or an explicit `result` assignment. It also reveals file-write behavior, overwrite guard, and local filesystem/path restrictions, which is substantial behavioral context.

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

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

The description is well-structured with clear paragraphs (environment, result semantics, file paths, local-path rules) and front-loads the purpose. However, the reminder to call `discover_api` and `read_skills` appears both in the main description and in the `code` parameter description, creating minor redundancy.

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 complex code-execution tool, the description covers the sandbox environment, blocked operations, result return, output file behavior, and path security, and an output schema exists for return values. It does not explicitly warn that API calls through `staad` may mutate the STAAD model or describe failure/timeout behavior, which is a minor gap given the destructive annotation.

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 five parameters have rich descriptions in the input schema (100% coverage), so the description does not need to re-describe them. It adds useful context for the `code` and `output_data_path` parameters by explaining the sandbox result mechanism and file-writing behavior, but this is complementary rather than essential because 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 opening sentence precisely states the action ('Execute Python code in a sandbox against the OpenSTAAD API') and names the concrete resources (`staad`, `input_data`). It is clearly distinguishable from sibling tools like `discover_api`, `read_skills`, `list_instances`, and `get_status`, which are all informational or instance-selection tools rather than execution tools.

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 a clear context for use: it instructs the agent to call `discover_api` and `read_skills` first, notes the pre-connected `staad` and `input_data` variables, and explains when to use `output_data_path` to avoid flooding the context window. It does not explicitly state when *not* to use the tool or name an alternative for code execution, so it stops 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 mark it readOnly, and the description reinforces this by describing a connection check. It adds useful behavioral context by stating return values (connection state, STAAD version, model path) and the dependency on list_instances for the alias. No contradictions 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 concise, with three short blocks that front-load the purpose. No filler or repetition of schema details.

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

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

For a low-complexity tool with one optional parameter, the description covers purpose, parameter usage, return values, and a cross-reference to list_instances. It is complete enough to guide selection and invocation without needing additional 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?

With 0% schema description coverage, the description compensates by explaining the instance parameter's origin (alias from list_instances) and when to omit it. It does not specify exact type constraints beyond the schema's anyOf, but for a single optional parameter this is sufficient semantic 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 uses 'Check the connection' to specify the action and resource, clearly identifying it as a status/inspection tool for a STAAD.Pro instance. It distinguishes itself from siblings like list_instances by focusing on connection state, version, and model path rather than enumeration.

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 provides explicit context on parameter usage: pass the instance alias from list_instances, and omit it when only one instance is running. It does not explicitly mention exclusions or when to prefer other sibling tools, but 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 already declare readOnlyHint=true, but the description adds valuable behavioral context: the alias is stable across model file changes, and a warning field appears for versions below 25.0.1. These details go beyond what annotations provide and help the agent anticipate edge cases.

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, front-loaded with the core purpose, and uses a short second paragraph for usage and conditional behavior. Every sentence contributes useful information, making it appropriately sized 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?

Given the tool's simplicity (0 params), rich output schema, and strong annotations, the description covers the essential aspects: what it lists, when to use it, and a notable behavior (version warning). No important gaps are evident.

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 tool has zero parameters, so the input schema is empty. The baseline for 0 params is 4. The description reinforces 'all instances' and the return fields, but since there are no parameters to explain, it cannot add more parameter-specific 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 opens with a specific verb and resource: 'List all running STAAD.Pro instances.' It clearly states the tool's function and distinguishes it from siblings by mentioning the returned fields (alias, process ID, file path, version) and its role as a precursor to execute_code.

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 explicitly says 'Call this before execute_code when multiple STAAD instances may be running so you can pick the right one.' This gives a clear when-to-use directive and a rationale, which is more than the minimal context needed for a simple listing 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?

Annotations already provide readOnlyHint=true and idempotentHint=true, so the description doesn't need to restate safety. It adds useful behavior context by mentioning sub-paths like 'staad-steel-design/assets/DESIGN_CODES' to read reference files, and explains skills provide domain-specific guidance.

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: the first sentence states the primary purpose, followed by prerequisite guidance and examples. No redundant or filler content.

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 tool with a single parameter and an output schema, the description fully covers how to use it: what it reads, how to discover available skills, and how to pass names or sub-paths. The output schema handles return values, so no additional explanation is needed.

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 covers 100% of the parameter description, but the description adds concrete examples ('["staad-analysis"]' and sub-paths) and clarifies that sub-paths read reference files within a skill. This goes beyond the schema's generic 'List of skill names or sub-paths'.

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 reads one or more skills by name, with the verb 'read' and resource 'skills'. It also distinguishes from sibling tools like discover_api (lists skills) by describing the sub-path capability for reading reference files.

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 explicitly instructs to 'Use discover_api first to list available skills', providing a clear prerequisite and context. It doesn't explicitly state when not to use this tool, but the read-only nature and examples suggest it is for accessing skill content, not for executing commands.

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