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

No annotations are present, so the description carries the full behavioral burden. 'Assign' implies a mutating operation, but the description says nothing about whether it replaces an existing assignment, requires existing geometry, or has side effects. This lack of detail is a notable gap for a modeling operation.

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 sentence with no filler. The action and main objects are front-loaded. It is efficient, though it errs on the side of being too terse rather than overly verbose.

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

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

The description is minimally sufficient to understand the basic operation but not complete enough for an agent choosing among many similar modeling tools. It omits when to use it, what prerequisites exist, what effects it has, and the role of the optional parameters. Given the large sibling tool set, this brevity leaves meaningful ambiguity.

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 0%, so the description must compensate. It does add meaning for the two required parameters: region_name is the target region and section_name is the section being assigned. However, the optional timeout and model_name parameters are not addressed at all, leaving part of the parameter surface unexplained.

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: 'Assign a section to a region.' It clearly names the two core entities involved, which distinguishes it from sibling creation tools like create_solid_section or create_shell_section at least by action type. However, it does not explicitly clarify whether the section and region must already exist.

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 usage guidance is provided. The description does not state when to use assign_section versus create_solid_section or other section-related siblings, nor does it mention prerequisites such as creating a section first or defining a region. The intended context must be inferred from the tool name and sibling list.

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. It mentions the base64 output but does not clarify side effects, prerequisites, whether a viewport must exist or be displayed, or what happens on failure. The read-only nature is left to inference.

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 wasted words. It is appropriately concise, though it sacrifices needed detail for brevity.

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

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

With no annotations, 0% parameter coverage, an output schema that does not explain invocation semantics, and a nearly identical sibling tool, the description is incomplete. It does not tell the agent how to set viewport, format, or timeout, nor how to distinguish this from 'get_viewport_image'.

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 0%, and the description does not compensate by explaining any of the three parameters: 'timeout', 'image_format', or 'viewport_name'. It adds no meaning beyond the bare property names and defaults.

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 ('capture'), a clear resource ('Abaqus viewport'), and states the output format ('base64 image data'). It is clear on its own, but it does not differentiate from the closely related sibling 'get_viewport_image', so it stops 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?

There is no guidance about when to use this tool versus alternatives such as 'get_viewport_image', 'set_viewport_display', or other viewport tools. The description only states what the tool does, not when it should be chosen.

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 alone must convey behavioral traits. It reveals only that the result is a concise human-readable status; it does not say whether the check mutates anything, what failure modes exist, whether a timeout causes errors, or what statuses can be returned. Behavior is largely 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?

One short sentence states the core behavior and output style with no filler, and the key information is front-loaded. For a simple health-check tool this is an efficient length.

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, has no required parameters, and an output schema exists, so the description does not need to explain return values. However, it omits usage context and timeout semantics, and the ambiguity with 'ping' is unresolved, leaving the definition minimally adequate rather than 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 has 0% description coverage and the description says nothing about the 'timeout' parameter, its units, or the meaning of null/default. The parameter is optional and self-named, which softens the gap, but the description does not compensate for the missing schema documentation.

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 operation ('Return') and the resource ('bridge status'), and it adds a useful output-shape cue ('concise human-readable'). It does not explicitly differentiate itself from the sibling 'ping', which likely serves a very similar purpose, so the tool name must carry that 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?

There is no statement about when to use this tool, when not to, or which alternative to prefer. With 'ping' and diagnostic tools like 'diagnose_job' and 'check_silent_failures' in the toolset, the agent is left to infer the intended use from the name alone.

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 and does reveal the tool runs the same checks as check_silent_failures and returns a compact text report. However, it does not explicitly state that the operation is read-only/non-destructive, nor describe error behavior or edge cases, leaving some behavioral ambiguity.

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 each sentence contributes: what it checks, how it relates to the sibling, when to use it, args, and return. No filler or 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 simple tool with two optional parameters, the description provides enough context to call it: usage timing, scope, and return format. The only notable omission is timeout parameter semantics, which prevents a perfect score.

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 0%, so the description must document both parameters. It documents model_name, but says nothing about timeout, its behavior, or acceptable values. Timeout is only partially self-explanatory, so this is a clear gap.

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?

Clearly states it performs a model integrity check on mesh, constraints, contacts, and volumes, and explicitly differentiates itself from check_silent_failures by being a fast subset. The scope is specific and an agent can immediately tell what it does.

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

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

Explicitly recommends using it after building a model and before submitting a job, giving concrete workflow context. It also names the sibling check_silent_failures and positions itself as a faster, compact alternative, though it does not explicitly state when to choose the full version.

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. It explains the validation behavior, both input modes, contract type semantics, and the Markdown report output. It does not explicitly state whether the operation is side-effect-free or how failures are surfaced, but the 'check/validates/returns report' framing makes the core behavior clear.

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-organized and efficient: purpose first, then modes, parameter details, contract types, and return value. No sentence is wasted, and the structure makes the information easy for an agent to parse.

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 no annotations and a bare schema, this description is complete. It covers the tool's purpose, both execution modes, every parameter's role, contract validation semantics, and the output format. An agent has enough information to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, and the description fully compensates. It defines contracts_json structure and required/optional fields, explains kpis_json with an example, and clarifies the capsule_id alternative. It also documents all five contract types, giving the agent enough detail to construct valid inputs.

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 object: 'Check physics contracts against KPI values', immediately clarifying the resource and operation. It further details that this validates simulation results against design requirements, distinguishing it from sibling tools like check_model_integrity or compare_capsules.

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

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

The description clearly explains when to use direct mode versus capsule mode, including that kpis_json is required if capsule_id is empty. It does not explicitly mention sibling alternatives or state when not to use the tool, but the mode-level guidance is concrete and actionable.

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, and it largely succeeds: it details the seven categories examined and states the return format is a structured Markdown report with pass/fail/warning findings. It does not explicitly state whether the operation is read-only or whether it requires an active Abaqus connection, but 'check' and 'detects' imply a non-mutating diagnostic.

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 front-loaded with a clear one-line summary and then uses a well-organized numbered list to communicate the seven check categories. Every section earns its place: categories, a clarifying philosophy sentence, and parameter explanations. The length is justified by the complexity of 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?

Given the high complexity of the tool, the description covers the core behavior, the model scope, the parameter defaults, and the output format. It is nearly complete, but it does not explain the timeout parameter's role or expected interaction with a live Abaqus session, which would make it fully self-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?

The schema has 0% description coverage, so the description must compensate for model_name, workdir, and timeout. It does explain model_name (default first available model) and workdir (working directory for job output checks), but it omits timeout entirely even though that parameter appears in the schema without documentation. This is partial compensation for low schema coverage.

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: 'Run silent-failure checks on the current Abaqus model,' and then enumerates 7 concrete check categories, making the purpose unambiguous. It does not explicitly differentiate itself from the similarly named sibling check_model_integrity, but the 'silent-failure' framing and focus on issues Abaqus does not report as errors provide enough conceptual 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 gives clear contextual guidance, especially 'These checks measure the model you built, not just the answer it produced,' which tells an agent to use this after model construction to catch hidden issues. It does not explicitly name alternative tools or state when not to use it, but the intended scenario is reasonably 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says the tool compares and shows differences, but does not mention whether it is read-only, whether capsules must be loaded first, whether it modifies state, or what scope of differences is covered.

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 with no redundant words. It is front-loaded with the main action and resource. However, the brevity leaves out important usage and behavioral context.

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

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

For a simple two-parameter tool with an output schema, the description is minimally adequate. The output schema presumably covers return values, so not explaining them is acceptable. However, missing guidance on when to use this tool and what exactly is compared makes the definition incomplete for an agent operating in a large sibling toolset.

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 0%, and the description does not compensate by explaining the two ID parameters. It only restates that they refer to two experiment capsules; it does not explain where the IDs come from, what format they should use, or what the difference is between the two parameters. The parameter names are readable, but the description adds little beyond the schema.

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

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

The description clearly states a specific action ('Compare') and a specific resource ('two experiment capsules'), and indicates the output concept ('show differences'). It is distinguishable from sibling capsule tools like create_capsule, list_capsules, load_capsule, and delete_capsule. However, it could be more precise about what kind of differences are shown (e.g., settings, contents, model data).

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 such as list_capsules or load_capsule. It does not state any prerequisites, exclusions, or conditions that would help an agent choose this tool confidently.

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 behavioral burden. It discloses output format (Markdown), content of suggestions (priority, risk, code template, description), supported patterns, and mode precedence. It doesn't explicitly state that the operation is read-only, but 'get suggestions/advice' makes that clear enough. Minor gap: no mention of timeout behavior or 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 well-organized with headers, bullet lists, and clear sections for modes, outputs, supported patterns, and arguments. It is slightly longer than strictly necessary because the pattern list and return details overlap with what the output schema likely covers, but every sentence contributes useful information.

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

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

For a two-mode advisory tool, the description covers mode selection, output structure, valid pattern IDs, and the relationship to diagnose_job. It is largely self-sufficient, but omits the timeout parameter and does not specify behavior when both diagnosis_result and pattern_ids are empty, which are minor gaps.

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 0%, so the description must compensate. It thoroughly explains diagnosis_result and pattern_ids, including format, source, and precedence. However, the timeout parameter is completely omitted from the Args section, leaving an agent unable to determine its meaning or default behavior.

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 ('Get auto-fix suggestions'), resource ('convergence problems diagnosed by the Solver Doctor'), and clearly distinguishes itself from siblings by being the advice tool tied to diagnose_job. It also explains both usage modes, so an agent can tell this apart from other analysis tools without needing to inspect 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?

Explicitly documents two modes: from diagnosis_result (output of diagnose_job) or direct pattern_ids, with a clear precedence rule ('If provided, pattern_ids is ignored'). It names the companion tool diagnose_job. It could be more explicit about when not to use it or what to do if no diagnosis is available, but the mode-based guidance is strong.

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?

There are no annotations, so the description carries the full behavioral burden. It states the create action but does not disclose side effects, whether existing boundary conditions are replaced, validation requirements, or what happens on failure.

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

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

The description is a single, parseable sentence with no filler words. However, it is under-specified rather than appropriately concise; the brevity omits necessary context that a tool description should provide.

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 8 parameters, 0% schema coverage, and no annotations, the description is not sufficient to guide correct use. It does not explain required inputs, defaults, component semantics, or the result of the operation, even though an output schema exists.

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 0% and the description adds no parameter meaning. The meaning of a1, a2, a3, timeout, step_name, model_name, and region_name is left entirely to schema field names, which is insufficient for correct invocation.

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 ('Create') and resource ('acceleration boundary condition'), which is enough to distinguish it from sibling BC-creation tools like create_displacement_bc or create_velocity_bc. It is minimal, but it is not vague or tautological.

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

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

No guidance is given about when to use this tool versus the many sibling boundary-condition tools, nor are there exclusions or prerequisites. An agent must infer the appropriate context solely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create a beam section' and lists integration values; it does not mention whether the section must reference an existing part or material, whether it mutates the model immediately, what side effects occur, or what success/failure looks like. This is barely more informative than a tautology.

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 text is short and front-loaded, but the brevity reflects under-specification rather than concise completeness. It only documents one of six parameters, and the Args section is incomplete, so the structure does not serve the agent's information needs.

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 presence of an output schema covers return-value expectations, but the description omits broader context such as how a beam section relates to parts, profiles, materials, or analysis steps; how integration affects behavior; and what prerequisites must exist before calling this tool. With six parameters and no schema coverage, this is a material gap.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's silence. It does add allowed values for the integration parameter ('BEFORE_ANALYSIS' or 'DURING_ANALYSIS'), which is useful. However, five other parameters including the required name and material_name are left completely unexplained.

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

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

The description states a specific verb and resource: 'Create a beam section.' This makes the tool's purpose reasonably clear and distinguishes it from unrelated tools. However, it does not explicitly differentiate it from the sibling tools create_solid_section or create_shell_section, so it stops short of full sibling 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 about when to use this tool versus alternatives such as create_solid_section, create_shell_section, or create_part_beam. An agent could infer that sections are used for beam modeling, but the description gives no explicit context for choosing this tool over its siblings.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It only states the creation effect and scope; it does not mention prerequisites, units, whether an existing body force is replaced or accumulated, step compatibility, or any 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, tightly written sentence that front-loads the core purpose and definition. There is 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 tool with six parameters, four required, no annotations, and zero schema coverage, the description is too sparse. It covers the general concept but omits parameter details, prerequisites, and behavioral context, even though an output schema is present.

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 0%, so the description must compensate for undocumented parameters. It adds meaning to magnitude and direction via 'force per unit volume,' but it does not explain step_name, model_name, name, or timeout semantics, leaving required parameters underspecified.

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 names a specific action ('Create'), a specific resource ('body force'), clarifies its physical meaning ('force per unit volume'), and scopes it to 'the entire model.' This distinguishes it from sibling load tools like create_concentrated_force, create_pressure_load, and create_gravity_load.

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 'on the entire model' implies when this tool is appropriate, but the description does not explicitly contrast it with alternatives such as create_gravity_load or other load types. No when-not-to-use guidance or alternative routing is 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?

No annotations are provided, so the description bears the full burden of behavioral disclosure. It says only that the tool 'creates' an object, giving no detail about prerequisites, effects on the model, failure modes, or whether invocation overwrites existing loads. This is a significant gap for a mutation 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 compact sentence with no filler, and the clarifying parenthetical earns its place. However, the brevity comes at the cost of missing useful parameter and invocation 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?

With five parameters, zero schema descriptions, and no annotations, the description is far too thin for an agent to invoke this tool correctly. It does not explain which step or model the heat flux applies to, what timeout does, or how this creation relates to other loads. The existence of an output schema does not compensate for the missing input context.

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

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

Schema description coverage is 0%, and the description does not document any of the five parameters. The parenthetical 'heat generation per unit volume' indirectly clarifies the meaning of magnitude, but name, timeout, step_name, and model_name remain unexplained.

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 a specific verb and resource: 'Create a body heat flux,' and clarifies the physical meaning as 'heat generation per unit volume.' This helps distinguish it from surface-level heat flux loads such as create_heat_flux_load, though it does not explicitly name the sibling.

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 guidance on when to use this tool versus alternatives like create_heat_flux_load, create_body_force, or the many other load/material creation siblings. The agent must infer usage purely from the tool name and the one-line 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?

No annotations are present, so the description carries the full behavioral disclosure burden. It only states that the tool creates a Linear Buckle step, implying mutation, but does not disclose whether the step is appended, what gets modified, how previous_step is used, or what side effects occur.

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 extremely concise and front-loaded with the core purpose. It contains no filler, though it could have used the space to add sibling differentiation or usage context without becoming bloated.

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 creation tool with six parameters, no annotations, and zero schema description coverage, a single sentence is inadequate. The output schema exists, but the description still leaves the agent without critical context about when to call this tool, how parameters relate to the step, and how it fits in the model-building 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?

The schema description coverage is 0% and the description provides no parameter details. With six parameters including num_modes, timeout, model_name, and previous_step, the agent receives no semantic explanation beyond the property names and defaults.

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 ('Create') and a specific resource ('a Linear Buckle step'), which clearly identifies what the tool does. The resource type also distinguishes it from the many other create_*_step siblings such as create_static_step and create_modal_step.

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 about when to use this tool versus alternatives. Given the large number of sibling step-creation tools, the description does not explain when a Linear Buckle step is appropriate or what prerequisites exist.

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 discloses that the tool persists session details (model info, job status, output files, version), but it does not explain side effects such as whether an existing capsule with the same capsule_id is overwritten, errors, timeouts, or any impact on the current session. This is adequate for a simple snapshot tool but lacks edge-behavior detail.

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 short, front-loaded with the main action, and every sentence adds value. The Args section provides meaningful parameter semantics without redundancy, and there is no filler or repetition of the schema's type/title information.

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

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

The description covers the tool's purpose, main parameters, and saved data, and an output schema exists so return values are documented elsewhere. However, it lacks timeout guidance, duplicate-capsule behavior, and explicit alternatives. These are meaningful gaps for a tool with no annotations and a missing parameter description.

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 0%, so the description must compensate. It gives useful meaning for capsule_id ('Unique identifier' with an example) and notes ('Optional description'), but completely omits the timeout parameter. Since one of the three parameters is undocumented in both the schema and the description, the parameter semantics are incomplete.

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

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

The description states a specific verb and resource: 'Capture current Abaqus session state into an experiment capsule.' It also lists exactly what is saved (model info, job status, output file inventory, Abaqus version), and the 'capture' verb clearly differentiates this tool from sibling capsule tools like list_capsules, load_capsule, and delete_capsule.

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

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

The description implies when to use the tool by saying the capsule is 'for reproducibility and later comparison,' which hints at using it before compare_capsules. However, it does not explicitly state when not to use it or mention alternatives such as load_capsule or list_capsules. Usage context is present but left to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create a concentrated force' and does not mention prerequisites, units, coordinate conventions, whether existing forces are overwritten, or the need for a valid step and region.

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 wasted words. However, it is arguably too terse for a tool with six parameters and no schema descriptions, so it sacrifices substance for brevity.

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

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

For a 6-parameter load-creation tool with no annotations and 0% schema description coverage, the description is far from complete. It omits critical context such as force component order, required existing geometry, step dependencies, and how this load relates to sibling load tools.

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 0%, so the description must compensate. It adds minimal meaning by indicating that region_name should reference a vertex or reference point, but it does not explain the force array semantics, timeout, step_name, model_name, or name parameters.

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

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

The description states a specific action ('Create a concentrated force') and a specific target ('on a vertex or reference point'). This clearly distinguishes it from sibling load-creation tools such as create_pressure_load, create_body_force, and create_moment_load.

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 'on a vertex or reference point' implies this tool is for point loads, but there is no explicit guidance about when to prefer this tool over alternatives like create_connector_force or create_moment_load. No exclusions or when-not-to-use scenarios 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'create', offering no information about side effects, requirements, units, how the BC is applied to the region, or what the operation does beyond the literal verb.

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 extremely short, but this is under-specification rather than effective conciseness. It provides only a minimal phrase and no structured information to help an agent understand 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?

Given a create tool with eight parameters, two required fields, no annotations, and an output schema that is not elaborated, the description is grossly incomplete. The agent receives no context about prerequisites, defaults, parameter relationships, or expected behavior.

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 0%, and the description mentions none of the eight parameters. It does not explain the meaning of `u1`, `u2`, `u3`, `region_name`, or the model/step defaults, leaving the agent without 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 states a specific action and resource: 'Create a connector displacement BC.' This is clear about what the tool does, but it does not differentiate it from the very similar sibling `create_displacement_bc`, so it falls short of full clarity.

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

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

No guidance is given about when to use this tool instead of alternatives like `create_displacement_bc` or `create_connector_force`. The context and selection criteria are entirely absent.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Create' and the target resource, offering no information about whether existing connector forces are replaced, how the force is applied (global/local coordinates), or any prerequisites for the connector/wire set. This is minimal 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 sentence is short and free of clutter, which is concisely written. However, it is under-specified rather than efficiently structured; there is no front-loading of key information beyond the basic action and target.

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 six parameters, no parameter descriptions, no annotations, and no usage guidance, the description is far from complete. An agent cannot confidently determine what values to provide for 'force', which step context is required, or what a valid connector/wire set is. The output schema exists, but it does not make up for the missing behavioral and parameter semantics.

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 0%, so the description must compensate for the six undocumented parameters. It does not mention name, region_name, force, step_name, timeout, or model_name, nor explain what the force array represents. The description adds no value to the bare schema field names.

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 ('Create') and resource ('connector force on a connector/wire set'), which distinguishes it from sibling load-creation tools like create_concentrated_force or create_body_force. It could be more explicit about what a connector force is, but the target resource is clear enough.

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

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

No guidance is provided on when to use this tool versus alternatives such as create_concentrated_force or create_connector_displacement_bc. The phrase 'on a connector/wire set' implies context, but there is no explicit when-to-use or when-not-to-use instruction.

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 only says 'Create', which adds little beyond the tool name; it does not state side effects, model requirements, whether the property is persisted, or how it relates to a contact simulation. This is insufficient for an operation with no annotation safety profile.

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

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

The description is concise and front-loaded, with no filler words, but it is under-specified: a single sentence that states the obvious without elaborating on context or parameters. It is compact but not sufficiently informative for a tool with four parameters and many siblings.

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 annotations, low schema coverage, and a description that only names the action, the tool definition is incomplete for correct invocation. The output schema may cover return values, but the description still fails to explain parameter semantics, prerequisites, or how this tool fits into the 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 0%, and the description does not mention or explain any of the four parameters. The defaults and titles in the schema provide only minimal clues, and the description does not compensate for the low coverage, leaving 'timeout', 'model_name', and 'friction_coefficient' without meaningful 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 a specific verb ('Create') and names a distinct resource ('contact interaction property'), so an agent can tell this is about creating a property object rather than a contact formulation. However, it does not differentiate itself from closely related tools like create_surface_to_surface_contact or create_general_contact, so it only meets the 'clear but no sibling differentiation' bar.

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 guidance on when to use this tool versus alternatives, no mention of prerequisites such as an existing model or part, and no statement about whether the property must be assigned to a contact interaction afterward. The description simply states the action without any usage context.

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, and it discloses nothing beyond the creation action. It does not mention that this mutates the named model (model_name), how previous_step chains onto prior analysis, what happens on name conflicts, or that solver increment parameters control convergence behavior.

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 efficient sentence with the verb and object front-loaded and no filler. However, this is under-specification rather than disciplined conciseness: for a 9-parameter tool it needs to earn its minimalism with more context elsewhere, which it does not.

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 9 parameters, zero schema descriptions, no annotations, and roughly ten sibling step-creation tools to disambiguate, a one-sentence description is far short of what an agent needs to invoke this tool correctly. The existence of an output schema covers return values only and does not compensate for the missing parameter, behavioral, and selection context.

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

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

Schema description coverage is 0% across 9 parameters, and the description adds no parameter meaning whatsoever. Terms like max_inc, min_inc, initial_inc, time_period, and previous_step remain ambiguous in an Abaqus context (e.g., max_inc could be read as maximum increment size vs. maximum number of increments), and nothing compensates for the missing schema descriptions.

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') plus a precisely named resource ('Coupled Temperature-Displacement step'), so the action and target are unambiguous. The physics-specific step type is inherently distinctive among the many sibling step tools (static, modal, heat transfer, dynamic implicit, etc.), though the description never explicitly contrasts it with them.

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

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

The single sentence offers no guidance on when to choose this tool over sibling alternatives like create_heat_transfer_step or create_static_step. There is no mention of prerequisites, model setup required for a coupled thermal-displacement analysis, or when this step type is appropriate versus others.

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, but it only states that a constraint is created and lists coupling_type values. It does not mention that the control point should be an existing reference point, that the surface must already exist, or that the DOF flags default to constrained behavior.

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 short and readable, but its 'Args:' section is misleadingly incomplete, presenting coupling_type as if it were the only argument. The brevity comes from omission rather than effective compression.

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 12-parameter creation tool with no annotations and no schema descriptions, this is far from complete. Required parameters, DOF flag meanings, defaults, and prerequisites are all missing; an output schema exists but does not compensate for the lack of input 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?

Schema description coverage is 0%, so the description should compensate by explaining parameters. It adds some value by listing valid coupling_type values, but it leaves the required parameters (name, control_point, surface_name) and the six DOF booleans (u1, u2, u3, ur1, ur2, ur3) undocumented.

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 ('coupling constraint between a reference point and a surface'), which helps distinguish it from sibling tools like create_tie or create_mpc_constraint. However, it does not explain the mechanical meaning of a coupling constraint beyond the name.

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 guidance on when to use this tool versus alternatives such as create_rigid_body_constraint, create_mpc_constraint, create_equation_constraint, or create_tie. No prerequisites, exclusions, or selection criteria are provided, so the agent must infer applicability.

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 only states that damage initiation is added, without mentioning whether it modifies an existing material, creates a subobject, overwrites prior damage settings, or requires a specific material 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 with no fluff, but it is overly terse for a tool with six parameters and no schema documentation. Conciseness is achieved at the cost of useful substance.

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 six parameters, zero schema description coverage, and no annotations, a one-sentence description is not complete enough for confident invocation. Although an output schema exists, the description still lacks essential parameter and side-effect context.

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

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

Schema description coverage is 0%, and the description mentions no parameters at all. Without any parameter explanations in either the schema or the description, an agent has no guidance on what 'fracture_strain', 'stress_triaxiality', 'strain_rate', or the other inputs actually mean.

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: 'Add ductile damage initiation to a material.' It clearly identifies the tool's purpose and is reasonably distinguishable from sibling material-creation tools, but it does not explicitly contrast with or name related alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no conditions under which it should not be used. Any usage context is only implied by the tool's name and one-line purpose.

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

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

With no annotations, the description must disclose side effects and behavior, but it only says 'Create a displacement BC.' It does not mention whether existing BCs are overwritten, how null u1/u2/u3 values are interpreted, or whether a model, step, and region are required context. This is effectively no behavioral disclosure.

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 sentence is short and front-loaded, but under-specification is not conciseness. It provides no structured information about parameters, defaults, or intended usage, so it earns minimal credit for brevity.

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

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

For an 8-parameter tool with no annotations and no visible output schema detail, the description is far too thin. It omits the role of region_name and step_name, default behavior for null displacement components, and how this BC interacts with other BCs, making confident invocation impossible.

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 0%, and the description does not mention any parameter, including required ones like name and region_name or the displacement components u1/u2/u3. The agent cannot learn displacement direction semantics, null-value meaning, defaults, or step association from the description.

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 ('Create a displacement BC'), making the core action identifiable. It does not differentiate from the sibling create_connector_displacement_bc or clarify which displacement components are involved, so it stops short of 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 given on when to use this tool versus velocity, acceleration, temperature, or connector displacement BCs. The only usage signal is the tool name itself, and no prerequisites or exclusions are stated.

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 available, the description carries the full burden of behavioral disclosure. It only says 'Create a Dynamic Implicit step' and does not mention side effects, prerequisites, whether it modifies an existing model, or what the operation returns. This is completely inadequate for a mutation-like 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 sentence with no fluff, but it is severely under-specified rather than concise. For a tool with 10 parameters and no parameter documentation, one sentence repeating the tool name does not earn its place as meaningful 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?

This is a complex tool (10 parameters, no annotations, no schema descriptions) yet the description provides almost no context. It fails to explain what a Dynamic Implicit step is, when to use it, or what the parameters control, making it impossible for an agent to correctly select and invoke it.

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 0% and the description mentions none of the 10 parameters. The tool has a required 'name' and numerous numeric/boolean options (e.g., nlgeom, max_inc), but none are explained anywhere in the description, leaving the agent without any insight into their semantics.

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

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

The description states a specific action ('Create') on a specific resource ('a Dynamic Implicit step'), which is clear and unambiguous. It distinguishes from sibling step-creation tools by naming the step type, though it does so purely by restating the tool name.

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 choose a Dynamic Implicit step over other step types such as static, explicit, or modal. The tool name implies the use case (dynamic implicit analysis), but the description contains no explicit context or alternatives.

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

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

No annotations are present, so the description must carry the full behavioral burden. It only states that a material is created; it does not disclose side effects such as adding to the current model, overwriting an existing material of the same name, or requiring an active Abaqus model/connection.

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 efficiently captures the action and domain without unnecessary detail.

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?

Even with an output schema present, the description is too thin for a 6-parameter creation tool with no annotations. It omits usage guidance, parameter semantics, and behavioral side effects, leaving too much for the agent to infer.

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 0% and the description adds no parameter-level meaning. It does not explain units, positivity constraints, the role of the optional density/timeout parameters, or how model_name influences the operation.

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 a specific resource ('linear elastic material') in the Abaqus domain. This clearly differentiates it from sibling material tools such as create_hyperelastic_material and create_viscoelastic_material.

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 guidance about when to choose this tool over related material creation tools, nor does it mention any alternatives or exclusions. An agent must infer usage solely from the tool name and sibling list.

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 disclosing behavior. It only restates the creation action and gives an analogy, but does not explain effects on the model, required model state, potential failures, or what happens when validation fails.

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 short and free of redundancy, which aids readability. However, it is under-specified for a constraint-creation tool; the single sentence does not provide enough operational context, so conciseness comes at the cost of completeness.

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 complexity, the lack of annotations, and 0% schema description coverage, the description is incomplete. It does not explain prerequisites, how host_region and embedded_region relate, validation behavior, or when this constraint type is appropriate, leaving an agent to guess at correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. The example 'reinforcement in concrete' subtly clarifies that embedded_region is the inserted object and host_region is the surrounding material, but timeout and model_name receive no explanation, and this minimal hint is insufficient to fully document the parameters.

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 and resource: 'Create an embedded region constraint' and gives a concrete example ('reinforcement in concrete'). It is not a tautology and is distinguishable from sibling constraint-creation tools through the unique resource type, though it does not explicitly contrast with any sibling.

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 usage guidance is provided. The description does not state when to choose this tool over other constraint creators such as create_tie, create_coupling_constraint, or create_mpc_constraint, nor does it mention any prerequisites like needing the host and embedded regions to already exist.

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 present, so the description carries the full behavioral burden. It only restates the tool's name in slightly expanded form ('fully fixed') and does not disclose what DOFs are constrained, what region type is expected, or any side effects beyond creation. The verb 'Create' implies mutation but adds no real transparency.

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 one short sentence with no filler, and the core concept is front-loaded. It is efficient, though minimal. This is appropriate conciseness, but it sacrifices substance covered by other dimensions.

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 5-parameter BC creation tool with many related sibling tools, the description is incomplete. It lacks usage context, parameter clarification, and behavioral detail. The presence of an output schema covers return values, but does not compensate for the missing selection and invocation 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?

Schema description coverage is 0%, and the description adds no parameter-level meaning. Required parameters like name and region_name, and optional ones like step_name, model_name, and timeout, are left entirely to their bare schema names. The description does nothing to compensate for the lack of schema documentation.

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

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

The description states a specific verb and resource: 'Create an encastre (fully fixed) BC.' The parenthetical clarifies what encastre means mechanically. It is clear but does not explicitly differentiate itself from sibling BC tools like create_displacement_bc or create_pinned_bc.

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

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

No guidance is given on when to use this tool versus sibling BC creation tools. It does not mention prerequisites, selection criteria, or situations where encastre is the appropriate boundary condition. The agent is left to infer usage from the name alone.

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. It only says 'Create', implying a mutation, but does not state whether the operation is additive, whether it modifies an existing model, what model_name defaults to, or whether there are side effects on existing constraints. The description also does not mention idempotency or failure behavior.

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

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

The description is concise and front-loaded with the core purpose. The args section and example are compact and readable. It earns a 4 because it is efficient, though it sacrifices completeness for brevity.

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

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

The tool is a modeling mutation with no annotations, and the description does not explain prerequisites (e.g., existing sets, model context), the nature of the constraint, or how it differs from related constraint tools. The output schema exists, so return values need not be described, but for a tool like this, more contextual guidance is needed for an agent to invoke it correctly in a real 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 0%, so the description must compensate. It documents the 'terms' parameter well, including the tuple structure and a concrete example. However, 'name', 'timeout', and 'model_name' are entirely unaddressed; their semantics rely on property names and defaults in the schema. Partial compensation for the most complex parameter, but incomplete overall.

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

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

The description states a specific verb and resource: 'Create a linear equation constraint.' This distinguishes it from sibling constraint tools like create_mpc_constraint, create_rigid_body_constraint, and create_tie at a category level, and the example clarifies the intended coupling of DOFs. It could be more explicit about what 'linear equation constraint' means in FEA, but it is not tautological or vague.

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 guidance on when to use this tool versus alternatives such as MPC constraints, rigid body constraints, or coupling constraints. The description does not mention prerequisites like existing sets or an active model, nor does it explain why an equation constraint would be preferred. An agent would have to infer usage from the tool name alone.

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 of behavioral disclosure. 'Create' implies a mutation, but the description does not mention side effects, prerequisites, model context, or what happens to the step sequence. It adds no behavioral detail beyond the verb 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 short and free of fluff, but it is under-specified rather than appropriately concise. A single generic sentence is not enough for a tool with 7 parameters and no supporting annotations.

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 parameter count, lack of annotations, and the large sibling cluster of step-creation tools, this description is wholly inadequate. It fails to explain the required name parameter, how the step integrates with the model, when to use it, or what output to expect.

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 0%, and the description mentions none of the 7 parameters. It does not compensate for the schema's bare titles and defaults, leaving the agent without meaningful guidance on fields like nlgeom, time_period, or previous_step.

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 identifies the resource as an 'Explicit Dynamics step,' which is clear and differentiates it from other step-creation siblings by analysis type. However, it does not explain what an Explicit Dynamics step does or why it differs from dynamic implicit, static, or modal steps.

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 guidance on when to use this tool over alternatives like create_dynamic_implicit_step or create_static_step. Any usage context must be inferred solely from the tool name and sibling list, which is not sufficient.

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. It only lists two arguments and does not mention side effects, prerequisites such as an existing model or step, validation behavior, or how the request is associated with the model.

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

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

The description is concise and front-loaded with its purpose, but the Args block presents only two parameters while the schema has six, which is structurally misleading. It is under-specified rather than efficiently complete.

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?

Even with an output schema present, the agent cannot determine how to target a specific step because step_name is undocumented, and model_name is also unexplained. The description is not complete enough for a six-parameter creation tool with no annotations.

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 0%, so the description must compensate but only documents 2 of 6 parameters. It adds useful meaning for variables (with example list) and frequency ('every N increments'), but leaves name, timeout, step_name, and model_name completely unexplained.

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

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

The description states a specific verb and resource: 'Create a field output request for a specific step.' This clearly identifies what the tool does and distinguishes it from sibling create_history_output_request by the field-output focus.

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 by the purpose sentence—use this when you need a field output request for a step. However, it provides no explicit when-not-to-use guidance and does not mention alternatives like create_history_output_request or get_field_output_summary.

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 that the tool creates an interaction, with no disclosure of model effects, ordering requirements, compatibility constraints, or failure behavior. The phrase 'all-inclusive' adds a hint of scope but little actionable behavioral detail.

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 with no filler and front-loads the core action. It is concise, though somewhat at the expense of necessary context.

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 five parameters, zero schema coverage, no annotations, and many similar contact-creation siblings, the description is far from complete. Even though an output schema exists, the description gives no information about required inputs, interaction semantics, or selection logic.

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 0%, and the description adds no meaning for any of the five parameters. In particular, the required interaction_property is completely unexplained, so an agent has no basis for constructing a valid call.

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?

Uses a specific verb 'Create' with a clear resource, 'a general contact (all-inclusive) interaction.' This is distinguishable from surface-to-surface contact tools, though it does not differentiate from the sibling create_general_contact_exp.

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

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

No guidance is given on when to use this tool versus the many related contact creation tools. It does not mention prerequisites, supported contexts, or why a user would select this over create_surface_to_surface_contact or create_general_contact_exp.

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 full responsibility for behavioral disclosure, but it only states that the tool creates a general contact. It does not mention side effects, prerequisites, required model state, or failure behavior beyond the basic mutation implied by 'Create'.

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 or redundancy. It is concise and well-structured, though the brevity sacrifices useful context in other dimensions.

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 five parameters, no annotations, and several closely related sibling tools, but the description only states the core action. It does not explain what interaction_property should contain, which analysis scenarios require this tool, or how it relates to other contact-creation siblings. The output schema helps, but the description alone is insufficient for reliable correct invocation.

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

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

Schema description coverage is 0%, and the description adds no parameter meaning. While names like 'name' and 'timeout' are somewhat self-explanatory, 'interaction_property' is opaque and no guidance is provided about expected formats or relationships to other contact definitions.

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

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

The description clearly identifies the verb ('Create') and resource ('general contact'), and scopes it to explicit analysis via the '_exp' suffix. It is clear enough about what the tool does, though it does not explicitly spell out how it differs from the closely named sibling create_general_contact.

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 only usage context is 'for explicit analysis', which is vague and does not explain when to choose this tool over create_general_contact or create_surface_to_surface_contact_exp. There is no when-to-use or when-not-to-use guidance, leaving selection among sibling tools to inference.

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

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

With no annotations, the description must disclose behavior but only repeats the fact of creation. It does not mention prerequisites, effects on existing loads, units, coordinate conventions, or error conditions. This is essentially no behavioral disclosure beyond the verb 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 single sentence is short and front-loaded, but it is under-specified rather than appropriately concise. It contains only the verb and object, leaving all useful context omitted.

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 tool with six input parameters, zero schema description coverage, no annotations, and many load-creation siblings, a one-line description is far from complete. An agent has no way to understand the required inputs, coordinate system, or relationship to other loads.

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 0% and the description adds no meaning to any of the six parameters. Magnitude, direction, step_name, model_name, name, and timeout are left entirely to the schema property names, so the description fails to compensate for the lack of schema documentation.

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

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

The description states the specific verb and resource: 'Create a gravity load' – this identifies the operation as creating a gravity load among the many load-related siblings. However, it does not distinguish gravity load from body force or concentrated force, so it lacks explicit sibling 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 provides no guidance on when to use this tool versus alternatives such as create_body_force, create_pressure_load, or create_concentrated_force. The absence of context means an agent must infer from the tool name alone.

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. It only states that a load is created and gives no information about prerequisites such as an existing model, region, or step, whether an existing load is replaced, required units, or what the response contains. This is a significant gap for a mutating 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 clear sentence with no filler or repetition, and the key differentiator ('surface') is included. It is concise, though so terse that it omits behavioral and parameter context that would be valuable for correct invocation.

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 no annotations and low schema coverage, the description is not complete enough for correct invocation. An agent is not told that the named region, model, and step must already exist, what units magnitude expects, or how the tool behaves if a load with the same name already exists. The presence of an output schema reduces the need to document return values, but the missing context is still substantial.

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 should compensate for missing parameter explanations, but it does not mention any parameter. The parameter names such as magnitude, region_name, step_name, and model_name are somewhat self-explanatory, but the description adds no detail about units, allowed values, required relationships, or the meaning of timeout.

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 a specific resource ('surface heat flux load'), and the word 'surface' differentiates it from the sibling create_body_heat_flux. An agent can tell exactly what this tool does 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?

No guidance is given about when to prefer this tool over alternatives such as create_body_heat_flux, create_pressure_load, or create_gravity_load. The only implied cue is the word 'surface' in the description, which is not sufficient routing guidance for an agent comparing many load-creation 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 provided, the description carries the full burden of behavioral disclosure. It only repeats the creation action and provides no information about side effects, model modifications, coupling with other steps, or required 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 short, but it is under-specification rather than conciseness. The single sentence essentially restates the tool name and provides no additional information, so it does not earn its place.

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

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

Given the high parameter count (9), the presence of many similar step-creation siblings, and the total absence of annotation or schema descriptions, this one-line description is completely inadequate for correct tool selection and invocation.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It does not mention any of the 9 parameters or their roles, leaving the agent to guess the meaning of fields like max_inc, min_inc, and time_period.

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 ('Create') and resource ('a Heat Transfer step'), making the basic action clear. However, it does not differentiate this step from siblings like create_coupled_temp_disp_step or create_static_step, so it stops short of full clarity.

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

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

No guidance is given on when to use this tool versus the many other step-creation tools available in the sibling list. There is no mention of intended scenarios, prerequisites, or alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It says the tool creates a request but does not mention side effects, whether it modifies an existing request, persists anything, or what happens on overwrite. The parameter hints are useful but do not cover the operational behavior of creating a history output request.

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

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

The description is compact and front-loaded with the action, followed by a short parameter list. It avoids fluff and each listed parameter has a terse definition. It is close to ideal in size, though the missing param explanations slightly reduce structural completeness.

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 create-type tool with seven parameters, no annotations, no parameter descriptions in the schema, and an output schema, this description is incomplete. It omits semantics for over half the parameters and provides no guidance on when this request fits into the broader workflow. More context about required setup and the meaning of step_name and model_name 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?

Schema description coverage is 0%, so the description must compensate. It explains variables, region_name, and frequency, which are meaningful additions. However, four of the seven parameters (name, timeout, step_name, model_name) receive no explanation beyond schema defaults, leaving significant gaps.

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

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

The description states a specific verb and resource: 'Create a history output request.' This is clear enough to distinguish from sibling tools like create_field_output_request and get_history_output, though it does not explicitly name those alternatives. The args list reinforces the intent by showing request-specific fields like variables and frequency.

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 such as create_field_output_request or when a history output request is appropriate. It only lists parameters without any context about prerequisites like requiring a step or model.

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, but it only states the creation action and material type. It does not mention side effects, model prerequisites, whether an existing material with the same name is overwritten, or whether an active Abaqus/model context is required.

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 contributes to identifying the tool's purpose. It is concise but arguably too terse relative to the seven-parameter schema, which prevents a higher 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?

For a creation tool with seven parameters, no annotations, and no parameter descriptions, this description is insufficient for correct invocation. It identifies the material family but omits required-input semantics, defaults' implications, prerequisites, and behavioral context; the presence of an output schema does not compensate for these gaps.

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 0%, so the description must compensate, but it only introduces the 'Mooney-Rivlin' model label, which hints that c10, c01, and d1 are constitutive coefficients without explicitly explaining them. The remaining parameters such as density, timeout, and model_name receive no semantic clarification at all.

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-resource pair ('Create ... material') and names the constitutive model 'hyperelastic (Mooney-Rivlin)', which makes the tool's purpose unambiguous. It is clearly distinguishable from sibling tools such as create_elastic_material, create_plastic_material, and create_viscoelastic_material.

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 about when to choose this tool over alternatives like create_elastic_material or create_viscoelastic_material. The agent must infer selection from the name alone; there are no prerequisites, 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?

With no annotations, the description carries the burden of behavioral disclosure. It communicates that the tool creates an instance, but it does not say whether this modifies the active assembly, whether duplicate instance names are allowed, or what side effects occur.

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 sentence with no wasted words. However, it is under-specified for a tool with four parameters and zero schema descriptions, so conciseness comes at the cost of useful detail.

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 an agent to call this tool correctly, it needs to know which parameters matter, how instance naming works, and what model context applies. None of this is supplied by the description or schema, so the definition is not complete enough despite the presence of an 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?

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It only maps to part_name implicitly and provides no meaning for timeout, model_name, or instance_name, leaving most parameters unexplained.

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

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

The description states a specific action ('Create') and resource ('an instance of a part in the assembly'), making the tool's core function clear. It does not explicitly distinguish it from siblings like translate_instance or rotate_instance, but the resource and operation are specific enough.

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

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

No guidance is provided about when to use this tool versus creating a part or manipulating an instance. Prerequisites, such as the part needing to exist in the assembly, are not mentioned, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It explains the load type and target surface, but it does not disclose units, coordinate-system conventions, the need for an existing edge set or step, overwrite behavior, or error conditions. This is thin for a mutating creation operation.

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 efficient sentence with the core concept front-loaded and the clarifying definition in parentheses. There is no filler or redundancy, though the brevity comes at the cost of missing necessary operational detail.

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 tool with 7 parameters, no annotations, and no schema descriptions, the description is too sparse. It omits required preconditions (existing edge set and step), direction semantics, unit conventions, and how it differs from sibling load tools. The presence of an output schema covers return values but not these usage requirements.

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 schema description coverage at 0%, the description must compensate by explaining parameters, but it only hints that 'region_name' refers to an edge set and that 'magnitude' is force per unit length. It says nothing about direction, step_name, model_name, timeout, or name semantics, leaving most of the 7 parameters underspecified.

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 identifies both the resource ('line load') and the target ('edge set'), adding the clarifying parenthetical 'force per unit length.' It is clear and self-contained, though it does not explicitly compare against sibling tools such as create_shell_edge_load.

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 guidance on when to choose this tool over related load-creation tools like create_pressure_load, create_body_force, or create_shell_edge_load. No prerequisites, exclusions, or alternative routes are mentioned, leaving the selection entirely to inference.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It only says the tool 'creates' a step, without mentioning side effects, prerequisites, whether it modifies the model, how it interacts with previous_step, or what it returns. For a mutation-style tool with zero annotation coverage, this is a significant 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 front-loaded sentence with no wasted words. It gets straight to the verb and object. It is concise, though arguably too sparse to carry the needed context for six parameters; that shortfall is better attributed to other dimensions.

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?

An output schema exists, so return-value documentation is not required from the description. However, with no annotations, no parameter descriptions, and no usage guidance, the definition is incomplete for an agent trying to correctly create a modal step. The description covers only the basic purpose, leaving operational context like model prerequisites and step ordering undocumented.

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 0%, so the description must compensate by explaining parameters. It does not. The word 'modal' hints at num_modes and model_name, but timeout units, previous_step semantics, description usage, and the meaning of model_name are left entirely to defaults and parameter names.

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 ('Create') and a specific resource ('Frequency (modal) analysis step'). The parenthetical 'modal' distinguishes it from the many sibling step-creation tools, such as create_static_step and create_explicit_step. It is clear but does not elaborate on the step's role in an analysis.

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

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

No guidance is given for when to use this tool versus the many sibling step creators. There are no exclusions, alternatives, or conditions such as 'use for eigenvalue extraction' or 'for transient response use create_dynamic_implicit_step instead.' The agent must infer usage from the tool name alone.

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 full behavioral burden. 'Create' implies mutation, and the target location is stated, but there is no disclosure of side effects, overwrite behavior, units, or required context. This is a thin behavioral picture for a mutating operation.

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 zero filler. The core action and target are front-loaded, and every word contributes to the 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 tool with six parameters, no annotations, and zero schema descriptions, one sentence is not enough. Missing details like moment component order, units, which parameters correspond to which entities, and how the load is attached to a step leave the agent to guess.

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 0%, and the description only weakly hints at region_name by mentioning 'vertex or reference point.' It does not explain the moment array's three component meanings, step_name semantics, model_name default behavior, or timeout usage, so the parameter burden is mostly unmet.

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 ('Create'), a specific resource ('moment load'), and a target ('on a vertex or reference point'). The tool is clearly distinguishable from force/pressure load siblings by type, though it does not explicitly name alternatives.

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

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

Provides no guidance on when to use a moment load rather than a concentrated force, pressure load, or other load type. It does not mention prerequisites, coordinate system expectations, or exclusions, so an agent gets no decision support beyond the action itself.

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 of behavioral disclosure. It says only 'Create an MPC constraint' and enumerates mpc_type values, but does not explain side effects, prerequisites, failure modes, or what happens to the model.

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

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

The description is concise and front-loaded with the core action. The Args section is minimal, but its brevity is appropriate; the main issue is omitted substance, not extra 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?

The tool has six parameters, four of which are required, and sits among many similar constraint-creation tools, yet the description provides no context about required inputs, model dependencies, or relationship to alternatives. An agent cannot reliably determine what control_point or surface_name refer to from this definition.

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 0%, yet the description documents only mpc_type choices. Required parameters such as control_point, surface_name, and name are left undefined, so the description does not compensate for the schema's lack of parameter documentation.

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

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

The description states a specific action and resource: 'Create an MPC constraint.' It is clear what the tool does at a high level, though it uses 'MPC' without explaining the concept and does not distinguish itself from sibling constraint-creation tools such as create_tie or create_coupling_constraint.

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

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

No guidance is given for when to use this tool versus the many related constraint tools. The description only lists mpc_type choices, leaving the agent to infer that an MPC is a distinct constraint type from the tool name alone.

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, but it only states the action and purpose. It does not say whether existing viewports are replaced or added to, whether a model or part must be present, or how the layout affects the viewport workspace. This is a meaningful transparency 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 one focused sentence plus a terse args list with no filler. The purpose is front-loaded, and the layout choices are compactly displayed.

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 small and has an output schema, so return-value documentation is not a major gap. Still, with no annotations and no notes on prerequisites or timeout behavior, the description leaves the operational context partially to inference.

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 description enumerates valid layout values (2x2, 3x1, 1x3, 2x1, 1x2), adding meaning beyond the plain string default in the schema. However, the timeout parameter is never mentioned, leaving it fully undocumented at 0% schema description coverage.

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

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

The description states a specific action ('create multiple viewports') and a purpose ('side-by-side comparison'), so an agent can tell what it does. It is distinct from single-viewport or capture-style tools like set_viewport_display and capture_viewport, though it does not name those alternatives explicitly.

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 'for side-by-side comparison' implies a primary use case, but there is no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. An agent must infer when this tool is preferable to set_viewport_display or capture_viewport.

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 that a part is created, with no mention of required Abaqus connection state, whether the part is added to a model, how defaults like point1/point2/model_name behave, or what the output contains.

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 wasted words. It is concise and easy to parse, though brevity comes at the cost of omitted context captured under other dimensions.

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 tool with six parameters, no annotations, and meaningful defaults, this description is not complete enough. It leaves unclear how length relates to point1/point2, what coordinate system is used, and whether model_name or timeout affect behavior.

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 0%, and the description does not mention any of the six parameters. It does not clarify the meaning of length, the coordinate roles of point1/point2, the timeout parameter, or the model_name default, so it adds no value beyond the raw schema.

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

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

The description states a specific verb-resource pair: 'Create a 3D wire (beam) part.' It clearly distinguishes this from sibling part-creation tools like create_part_sphere or create_part_cube by specifying the beam/wire geometry type, and from create_beam_section by explicitly saying 'part.'

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

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

No guidance is given about when to use this tool versus alternatives, prerequisites, or when not to use it. The name and description imply beam part creation, but there is no explicit routing or exclusion information compared to other create_part_* 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 provided, the description carries full behavioral disclosure burden. It discloses that the created part is deformable (a genuine trait beyond the schema), but says nothing about side effects, whether the part is added to the model specified by model_name, what happens on duplicate names, or any operational dependencies.

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 front-loaded sentence with no filler — every word earns its place. It is appropriately sized for what it communicates, though slightly terse given the missing supporting detail scored in other dimensions.

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 creation tool with 6 parameters, 0% schema coverage, and no annotations, the description is too thin. The output schema partially relieves it from documenting return values, but usage context, prerequisites, parameter meaning, and behavioral effects are all absent, leaving the agent to guess.

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 0%, so the description must compensate, but it explains no parameters. Width/height/depth get implicit meaning from 'cube/box' as the box's extents, yet units are unspecified and model_name/timeout semantics are entirely unexplained.

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') with a clear resource ('3D deformable cube/box part'). The shape qualifier 'cube/box' inherently distinguishes this from sibling tools like create_part_sphere, create_part_cylinder, create_part_beam, and create_part_plate, and 'deformable' adds a meaningful part-type qualifier.

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 by the name and description — an agent can infer to use this when a box-shaped part is needed — but there is no explicit when-to-use guidance, no exclusions, and no mention of alternatives or prerequisites such as a live ABAQUS connection or an existing model.

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 of behavioral disclosure, but it only states that a deformable cylinder is created. It does not disclose side effects on the current model, the target model_name, uniqueness requirements for 'name', units, or what the tool returns. The word 'deformable' adds some object-type context but is thin behavioral detail.

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 front-loaded sentence with no filler; it uses the space efficiently. It is slightly under-specified, but as a concise statement of what the tool creates, it earns its place.

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

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

For a simple part-creation tool with an output schema, the core purpose is clear and parameter names are mostly self-explanatory. However, the lack of usage guidance, model-target context, and parameter explanation leaves the definition only minimally complete for an agent deciding among many sibling creation tools.

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 0%, yet the description does not compensate by explaining any parameters. While 'radius' and 'height' are inferable from 'cylinder', the description adds no meaning for 'name', 'timeout', or 'model_name', and does not clarify required dimensions or defaults beyond what the schema already shows.

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 names a specific action ('Create') and a distinct resource ('3D deformable cylinder'), which clearly differentiates it from sibling part-creation tools like create_part_sphere, create_part_cube, and create_part_plate. The modifier 'deformable' also distinguishes the part type from rigid alternatives.

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

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

No guidance is given about when to choose this tool over other create_part_* tools, nor are any conditions or prerequisites mentioned. The only implied context is the tool name and sibling list, leaving the agent to infer usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that a part is created and that it is a 3D planar shell; it does not disclose side effects, prerequisites, default model behavior, units, or how the operation affects the current model.

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 with no filler or redundancy, and the key information is front-loaded. However, it is somewhat under-specified for the given parameter set, so it earns a high but not perfect score for 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 five parameters, no schema descriptions, and no annotations, this description is too sparse to fully support correct use. While an output schema exists, parameter meaning, units, and usage context are missing, leaving important gaps for an agent to resolve independently.

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 0%, and the description does not explain any parameter semantics. Width and height are only implied as planar dimensions by the word 'planar', and name, timeout, and model_name are entirely unexplained, leaving the agent without the meaning needed for correct invocation.

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 verb ('Create') and resource ('3D shell (planar) part'), which distinguishes this tool from sibling part-creation tools like create_part_cube, create_part_cylinder, and create_part_sphere. The 'planar' qualifier makes the intended geometry 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 implies usage for creating planar shell parts but provides no explicit guidance on when to choose this tool over alternatives. With many sibling part-creation tools, explicit differentiation such as 'use for flat rectangular plates' would be more helpful.

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 restates that a sphere is created, without mentioning whether an active model is required, how radius is interpreted, whether existing parts are affected, or any failure conditions.

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

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

The description is a single short sentence with no wasted words, which is concise. However, it is under-specified: brevity comes at the expense of essential usage and parameter information, so the sentence does not fully earn its place as an adequate definition.

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 tool with four parameters, no annotations, and an output schema not shown in the description, the definition is far too sparse. It omits units, defaults, required-parameter rationale, and any note about how the part is integrated into the current model, leaving significant gaps for 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?

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings, but it does not. It fails to describe name, radius, timeout, or model_name, leaving the agent without semantic context beyond raw schema types.

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

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

The description states a specific verb and resource: 'Create a 3D sphere part.' This cleanly distinguishes it from sibling tools like create_part_cube, create_part_cylinder, create_part_beam, and create_part_plate, so an agent can tell exactly which geometry this tool targets.

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

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

No guidance is given about when to choose this tool over other part-creation tools, nor are any prerequisites, exclusions, or context for calling it provided. An agent must infer usage entirely from the tool name and sibling list.

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