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 mentions the basic create action and vertex ordering but does not disclose prerequisites (e.g., an open model, existing property_name), side effects, error conditions, or return behavior. 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?

A single, front-loaded sentence with no filler. It efficiently conveys the core action and input, though it could benefit from a bit more structure (e.g., separating purpose from usage).

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 3 parameters, 0% schema coverage, and no annotations, this description is insufficient. An agent would not know what property_name refers to, whether the model must be open, or what the output schema returns. The description is far too minimal for correct invocation without prior knowledge.

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 the 'points' format (array of [x,y,z] vertices in order) but does not clarify the meaning of 'property_name' or the optional 'name' parameter. The most critical parameter after points is left ambiguous.

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 ('crea' = creates), a resource ('losa o muro' = slab or wall), and the input format (vertices in order). It distinguishes the action from property-definition siblings like etabs_define_slab and etabs_define_wall, though it does not explicitly name the sibling it is not.

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

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

No guidance on when to use this tool versus alternatives such as etabs_add_frame, etabs_define_slab, or etabs_areas. The usage context is only implied by the action, with no explicit conditions or exclusions.

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 exist, so the description must carry the full burden. It only states that it 'creates' a beam/column, but does not disclose side effects (e.g., modification of the model, requirement for unlocking), error handling, or return values. The presence of an output schema is not reflected in the description.

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

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

The description is a single, concise sentence that conveys the core purpose without any unnecessary wording. It is well-structured and easy 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?

While the tool is relatively simple, the description omits essential context: parameter meanings, return format, units, coordinate system assumptions, and interactions with the model state. The lack of parameter explanations and behavioral details makes it incomplete for reliable use.

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 descriptions are 0% (no parameter documentation). The description does not compensate by explaining any of the 8 parameters (xi, yi, zi, etc.). Even obvious ones like coordinates are left implicit, and 'name' and 'section' are not defined. This is a critical 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?

The description 'Crea una viga o columna entre dos coordenadas globales' clearly states the action (creates) and the resource (a beam or column between two global coordinates). It is distinct from sibling tools like etabs_add_area, but does not explicitly differentiate from other add operations, so a slight deduction.

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 (e.g., etabs_frames for listing, etabs_add_area for areas). There is no mention of prerequisites like an open model or unlocked state, nor any indication of when this tool is preferred over similar add actions.

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 'creates', implying a mutation, but does not state that the model must be open/unlocked, whether existing combinations are overwritten, or what errors may occur. This is a significant gap for a model-modifying 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 short and front-loaded, with no filler. However, it is under-specified rather than efficiently complete, providing minimal detail beyond the action and one parameter mapping.

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, 5 parameters, and 0% schema coverage, the description is incomplete. It does not explain how cases and factors pair, valid combo_type values, preconditions, or behavioral side effects. An output schema exists but does not compensate for the missing usage and parameter 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%, so the description must compensate. It explains only case_type with a 0/1 mapping. The required cases and factors arrays are completely unexplained, and combo_type is left undocumented, leaving the agent to guess the expected format and relationships.

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 clear verb and resource: 'Crea una combinacion de carga' (creates a load combination). It is unambiguous about the primary action, though it does not differentiate itself from sibling tools like etabs_load_cases or etabs_load_combinations, and the added case_type mapping slightly muddies the scope.

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. The case_type mapping hints at a distinction between load case and combo, but it is not explained when each should be chosen or how this tool relates to etabs_load_cases/etabs_load_combinations.

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 disclose behavior fully. It only states the action and load_type mapping, but does not explain the effect of add_analysis_case or self_weight_multiplier, nor any side effects like overwriting existing patterns. Permissions and return behavior are also absent.

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: the purpose is stated first, followed by the load_type mapping. It is efficient with words, though it sacrifices necessary detail. For its length, it is well structured.

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

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

With four parameters, one required, and no annotations, the description is incomplete. It fails to explain the purpose of add_analysis_case and self_weight_multiplier, any behavior on name conflicts, or the nature of the return value despite an output schema existing. An agent would likely need additional context to call it 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%, so the description must compensate. It explains load_type with a numeric mapping, but leaves add_analysis_case and self_weight_multiplier entirely unexplained, and only implicitly covers name. This is insufficient for four 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 the verb and resource: 'Crea un patron de carga' (creates a load pattern) and provides a useful load_type mapping. It is unambiguous about the primary action, though it does not explicitly differentiate from sibling tools like etabs_load_patterns (which likely lists patterns), but the name 'add' and the action verb suffice.

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. It does not mention prerequisites like an open model, whether it replaces existing patterns, or that etabs_load_patterns should be used for querying. The description implies a create operation but provides no explicit context for selection.

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

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

With no annotations, the description carries the full burden, but it only lists output content ('su propiedad y nudos de contorno') and does not state read-only behavior, pagination semantics, or how the optional story filter affects results. The absence of side-effect disclosure is a gap, though nothing contradicts the annotations.

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

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

The description is a single compact sentence with no filler or repetition, and the core resource detail is front-loaded. It earns conciseness, though the brevity contributes to missing usage and behavioral 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 tool with three parameters, no annotations, and no action verb, the description is too thin. The presence of an output schema reduces the need to describe return values, but the agent still lacks when-to-use guidance, parameter semantics, and behavioral expectations.

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 says nothing about limit, story, or offset. The agent receives no help understanding that story filters by level or that limit/offset paginate results.

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

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

The description identifies the resource as area elements (slabs and walls) and specifies they carry a property and contour nodes, which helps distinguish it from siblings like etabs_area_sections or etabs_points. However, it is a noun phrase with no explicit verb, so the agent must infer that the tool retrieves/lists these elements rather than creating or modifying 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?

No guidance is given about when to call this tool instead of related tools such as etabs_frames, etabs_points, etabs_area_sections, or etabs_define_slab/wall. There are no context cues, exclusions, or alternative suggestions.

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 must convey behavioral traits. It does not disclose whether the operation is read-only, the format of the output (e.g., a list of strings), or any potential side effects. The description is purely functional, lacking transparency about the tool's behavior beyond its purpose.

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

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

The description is a single, concise sentence that front-loads the core purpose without any extraneous words. It is efficiently structured and easy to scan, making it ideal for quick comprehension.

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 no parameters and an output schema, the description is mostly complete. It identifies the return type (names of area properties) and specific categories (slabs, walls, deck), but lacks usage context relative to sibling tools, which slightly reduces completeness. The output schema covers return format details, so this is acceptable.

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

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

The tool has zero parameters, so there is nothing to explain. The description correctly omits parameter details, and per the rubric, a baseline of 4 is appropriate for tools with no parameters. No additional semantic explanation is needed.

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

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

The description clearly states the tool provides names of area properties (slabs, walls, deck), specifying the resource and scope. It distinguishes itself from siblings like etabs_frame_sections by focusing on area sections, though it doesn't explicitly say it 'returns' or 'lists' them, leaving a slight ambiguity.

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 etabs_areas or etabs_frame_sections. The description only states what it does, leaving the agent to infer context, which is inadequate for a tool with many 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?

The description discloses no side effects, required permissions, or behavior such as replacement of existing loads (despite the 'replace' parameter). It only names the action without any operational details.

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, direct sentence that conveys the essential purpose without unnecessary words. It is well-structured and front-loaded with the core action.

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 lacks context about the expected output, effect on the model (e.g., whether it requires an unlocked model), and any interactions with other tools. Given the absence of parameter details, the agent has insufficient information for 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?

Paramater descriptions are absent entirely (schema description coverage is 0%). The tool description does not clarify the meaning of 'area', 'load_pattern', 'value', 'direction', or 'item_type', leaving parameter semantics undefined.

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

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

The description clearly states the action: assigning a uniform load (force per area) to a slab or wall. It specifies the resource type and units, leaving no ambiguity about the tool's primary function.

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 explicit guidance on when to use this tool versus alternatives, and no mention of prerequisites or conditions. The usage context is only implied by the action described.

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, but it only states the assignment action. It does not disclose that replace defaults to true (overwriting existing loads), how units/direction are interpreted, or whether a lock/unlock state is required. The mutation semantics are implied by 'asigna' but no behavioral consequences are described.

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 description is free of filler and front-loads the core action and object. However, it is so terse that it omits critical behavioral and parameter details, making it concise but not fully appropriate for the tool's complexity.

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 six parameters, zero annotations, and zero schema descriptions, this one-line definition is not enough for an agent to call the tool correctly. Required parameters like load_pattern and value have no explained semantics, and the output schema does not compensate for missing 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 must explain parameters; it only clarifies that value represents force per length and that the target is a frame. It leaves load_pattern, direction, replace, and item_type undefined, forcing the agent to guess at valid values 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 Spanish description names a concrete action ('asigna' = assigns), the target resource (a frame), and the load type (uniformly distributed, force per length). This is enough to distinguish it from sibling etabs_assign_area_uniform_load, which targets areas rather than frames.

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 over alternatives such as etabs_assign_area_uniform_load or about prerequisites like an unlocked model. The only implicit context is the frame target in the description, so an agent must infer usage from the name rather than from explicit instructions.

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 disclosing behavior, but it only restates what the tool returns. It does not say whether this is a read-only operation, whether prior analysis or selection is required, what units are used, or whether the model must be open.

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 filler, and the core concept is front-loaded. 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 no-parameter tool with an output schema, the description covers the essential scope but leaves the selection mechanism implicit. It does not explicitly state that the user must first select cases/combinations via etabs_select_output or that analysis results must exist, so the context is adequate but not fully 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 input schema has zero parameters, so there is nothing for the description to clarify about parameter semantics. The baseline of 4 applies because no parameter documentation gap exists.

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

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

The description identifies the resource (base reactions) and scope (selected load cases/combinations) clearly, distinguishing it from related output tools like joint reactions or frame forces. It lacks an explicit verb such as 'get' or 'retrieve', but the noun phrase is specific enough for an agent to understand the tool's purpose.

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 'para los casos/combinaciones seleccionados' implies that the user must select load cases/combinations beforehand, giving some contextual guidance. However, it does not explicitly mention when to use this tool instead of siblings like etabs_joint_reactions or etabs_frame_forces, nor does it name prerequisites such as etabs_select_output.

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 does not disclose side effects such as model modification, overwriting existing sections, or error conditions. The single verb 'define' is ambiguous about the tool's impact on the ETABS 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 concise sentence with no superfluous content. It is well-structured for brevity, though this brevity contributes to the lack of contextual 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?

Given the absence of annotations and the minimal description, the tool is not self-contained. An agent would need additional knowledge about ETABS circular sections, units, and input requirements to use this tool correctly. The description does not provide enough context for safe 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?

The schema lists three parameters (name, diameter, material) but provides no descriptions. The description does not explain their units, valid ranges, or relationships (e.g., whether 'material' must reference an existing material definition). This leaves the agent without essential input 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 the action 'Define una seccion circular' clearly, naming the resource. However, it lacks specific detail on the scope or conditions (e.g., whether it creates a new section or modifies an existing one), which distinguishes it only moderately from sibling tools like 'etabs_define_rectangular_section'.

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, prerequisites, or typical scenarios. The description is a bare statement with no actionable context for an agent.

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 says 'Define', implying a mutation, but does not disclose side effects (e.g., whether it overwrites an existing material, if it requires the model to be unlocked, or what happens on duplicate names). It also does not mention any error handling or return behavior. The units note ('en las unidades actuales') is helpful but insufficient.

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, which is efficient. However, it is under-specified, omitting critical context that would help an agent use the tool correctly. It is not verbose, but it lacks the necessary structure to be fully helpful.

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 definition tool with 6 parameters, 3 required, and no annotations, the description is incomplete. It does not explain the behavior when a material with the same name exists, does not clarify the units beyond 'current units', and does not mention the output (though an output schema exists). An agent would likely need to infer or seek additional information to call this 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%, so the description must compensate. It only clarifies fc (f'c) and modulus, but does not explain poisson, weight_per_volume, or thermal_coefficient. While it maps two required parameters to their engineering meanings, the other parameters remain unexplained, leaving a significant gap for a tool with 6 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 verb 'Define' and resource 'material de concreto' (concrete material), and mentions f'c and modulus, which are key properties. It is clear and distinguishes from etabs_materials which likely lists materials. However, it does not mention the other parameters (poisson, weight, thermal) which could add clarity, but the core purpose is clear.

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 etabs_materials or other definition tools. It does not state when not to use it, prerequisites, or mention any alternative tools. The description only explains what it does, not the context for selection.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only says 'Define', implying a model mutation, but does not disclose whether an existing section is overwritten, whether the material must already exist, 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?

A single sentence with no filler; the core purpose is front-loaded and the dimension clarification is parenthetical. Every word contributes useful 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?

The tool is simple and an output schema exists, so return-value documentation is not required. However, the description omits units, material prerequisites, and duplicate-name behavior, leaving noticeable gaps for an 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?

With 0% schema coverage, the description must explain parameters but only maps depth to 'peralte' and width to 'base'. Name and material are left entirely unexplained, so the description only partially 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 clearly states the tool defines a rectangular concrete section, using the specific verb 'Define' and a concrete resource. It distinguishes itself from the sibling etabs_define_circular_section by explicitly saying 'rectangular', and clarifies the depth/width terminology.

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 intended use is implied by the phrase 'rectangular section', which points to this tool over the circular-section sibling, but there is no explicit when-to-use, when-not-to-use, or alternative guidance. No prerequisites such as an existing material are mentioned.

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 'Define', implying a mutation, but reveals nothing about side effects, overwriting behavior, required model state, or response characteristics. The agent cannot infer any behavioral traits beyond the 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 (one sentence) but this is under-specification rather than conciseness. It lacks any structure or front-loaded useful information. Every sentence should earn its place, but this single sentence provides almost no value.

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 definition tool with 5 parameters and no annotations, the description is grossly incomplete. Even with an output schema present, the agent cannot understand what the tool actually accomplishes, what inputs mean, or how to invoke it correctly. It fails to cover basic operational 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 mention any of the five parameters (name, material, thickness, slab_type, shell_type). The agent gets no additional meaning from the description beyond what the raw schema field titles provide, which is minimal.

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 'Define una propiedad de losa' is nearly a direct translation of the tool name 'etabs_define_slab', adding only the generic word 'propiedad' (property). It does state a verb and resource but provides no specificity about what slab property or how it differs from sibling tools like etabs_define_wall or etabs_define_rectangular_section. This borders on a tautology.

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 mention of when to use this tool versus alternatives, no prerequisites, no exclusions, and no context about typical workflows. The single sentence offers zero guidance on selection among the many define_* 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?

With no annotations and only a one-line description, the tool's side effects, requirements, and postconditions are completely undisclosed. The description does not mention what happens to existing definitions, required preceding steps, or any validation 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 one-sentence description is terse and free of fluff, but it is so sparse that it sacrifices useful information. It is concise but not effectively structured toward agent comprehension.

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 and no annotations, the description is grossly incomplete. It does not explain required inputs, units, defaults, or the role of the wall property within the broader model 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?

The schema provides no descriptions for name, material, thickness, or shell_type, and the description does not clarify any of them. Since schema_description_coverage is 0%, the description fails to compensate with any parameter meaning.

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

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

The description states a verb ('Define') and a resource ('wall property'), but it is too generic and does not distinguish this tool from other 'define' siblings like define_slab or define_concrete_material. More specificity about the wall property context is needed.

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 alternative definition tools or when defining a wall property is appropriate. The description lacks any contextual usage direction.

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

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

No annotations are provided, so the description carries the full burden. It only states the purpose and item_type meanings; it does not disclose whether the operation is read-only, requires prior analysis, or how results are scoped or returned. The output schema exists, but the description itself adds little behavioral context.

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

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

The description is very brief: one purpose statement and an item_type legend. It front-loads the core purpose and has no filler, so it earns high marks for conciseness, though the brevity contributes to missing parameter 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?

Given three parameters and no annotations, the description is incomplete: it does not clarify what name should contain, what limit controls, or when to use this tool relative to sibling output tools. The output schema reduces the need to describe return values, but the missing input semantics are a significant 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. It explains item_type values (0=object, 1=element, 2=group, 3=selection), which is useful, but it leaves 'name' and 'limit' undefined and does not explain how they interact with item_type.

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 noun phrase 'Fuerzas internas en frames' rather than an explicit verb like 'get' or 'list,' but it clearly identifies the resource (frames) and the kind of data (internal forces). It does not explicitly differentiate from sibling output tools such as etabs_base_reactions or etabs_select_output.

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 prefer this tool over alternatives like etabs_select_output or etabs_base_reactions. The item_type mapping hints at filtering modes but does not state the use case, prerequisites, or exclusions.

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. It states the returned data includes section and end nodes, but does not disclose pagination behavior (limit/offset), filtering by story, or whether the operation is read-only. 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 concise sentence with no wasted words. It front-loads the core resource, though the brevity omits necessary operational details, which is more a completeness issue than 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?

With three parameters and an output schema, the description is insufficient. It does not explain pagination, filtering, or the meaning of the parameters. An agent cannot correctly call this tool without additional information.

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 does not mention limit, story, or offset. The schema provides defaults but no semantic meaning, and the description does not compensate, leaving agents to guess the meaning of 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 identifies the resource (frame elements) and specifies they include assigned sections and end nodes, which distinguishes it from sibling tools for areas, points, and forces. It lacks an explicit verb like 'get' or 'list,' but the intent is clear.

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 siblings like etabs_frame_forces or etabs_add_frame. It does not mention scenarios, prerequisites, or exclusions.

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 discloses that geometric properties are included conditionally ("si se piden"), which implies the include_properties parameter controls this. However, it does not state whether the operation is read-only, any side effects, pagination, or error behavior. The conditional behavior is partially transparent but lacks depth.

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. It front-loads the resource (frame sections) and immediately clarifies the optional behavior. Every word contributes to meaning, achieving high informational density without verbosity.

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 details are presumably covered there. However, the description lacks usage context (e.g., when to list sections versus define them) and does not explain the domain of 'frame sections' relative to other ETABS concepts. For a simple read tool with one parameter, it is minimally adequate but not comprehensive given the absence of annotations and the large sibling set.

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 single parameter include_properties is explained by the phrase "con sus propiedades geometricas si se piden," which directly maps to the boolean. This adds meaning beyond the schema, which only provides a title and default. The description clarifies that setting it to true includes geometric properties. It does not detail what those properties are, but the core semantic is conveyed.

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 that the tool returns defined frame sections, optionally with geometric properties. The verb is implicit (list/get), but the resource is explicit. It distinguishes from sibling tools like etabs_frames (which likely returns frame elements) and etabs_define_rectangular_section (which defines new sections), but does not name them 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?

No guidance is given on when to use this tool versus alternatives such as etabs_frames or etabs_area_sections. It does not mention that it is a read-only listing tool or contrast it with definition tools. The agent must infer usage from the name and description alone, which is insufficient given the large sibling set.

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 disclosing behavioral aspects. It does not state whether the operation is read-only, safe, or has side effects. While it likely lists names without modification, this is not explicitly communicated.

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, consisting of a single short phrase. It contains no unnecessary words or repetition, and the structure is straightforward.

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 very simple (no parameters, likely returns a list of names), but the description does not specify the return format or any edge cases. It is adequate for a minimal getter, though slightly more detail (e.g., 'returns an array of strings') would improve completeness.

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

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

The input schema has zero parameters, so the baseline is 4. There is nothing to describe beyond the schema. The description does not contradict or confuse parameter usage.

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 tool's purpose as retrieving the names of grid systems in the model. While it lacks an explicit verb like 'get' or 'list', the meaning is unambiguous and distinguishes it from sibling tools that return other entity names.

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. It does not mention any conditions, prerequisites, or scenarios where this tool is preferred.

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 behavioral traits, but it only explains parameter values. It does not mention that this is a read-only query, what the response contains beyond the name, any side effects, or error conditions. This is a significant gap for a query 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 two sentences, front-loaded with the purpose and then parameter guidance. Every sentence adds value, and it avoids unnecessary fluff, making it highly efficient.

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

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

The tool has three parameters and an output schema exists, so return format is not needed. However, the description leaves 'name' and 'limit' semantics ambiguous, and it lacks a general statement about the tool's behavior beyond the specific 'All' case. It is adequate for a simple query but not fully 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?

Schema description coverage is 0%, so the description must compensate. It explains the meaning of item_type (0-3) and the special combination with name='All'. However, it does not clarify the role of 'name' generally or the 'limit' parameter, leaving those under-specified.

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

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

The description clearly states the tool retrieves joint reactions ('Reacciones en nudos'), which is a specific verb-resource pair. It distinguishes itself from siblings like etabs_base_reactions and etabs_frame_forces by the resource (joints vs. base or frames), but 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?

It provides a concrete usage tip for querying the entire model (item_type=2, name='All'), which is helpful. However, it does not explain when to prefer this tool over other reaction tools or mention any exclusion criteria, leaving the decision to the agent.

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

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

The description implies a read-only query (returning names) and no side effects, but it does not explicitly state that it has no destructive or modifying behavior. The absence of annotations leaves the behavioral contract implicit.

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, consisting of a single phrase. It is front-loaded with the essential information and contains no unnecessary words.

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

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

For a simple getter, the description is mostly sufficient, but it does not specify the return format (e.g., list of strings, array) or whether the names are sorted. Given that there is no output schema, a bit more detail would improve completeness.

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

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

The tool has no parameters, so there is nothing to describe. The schema is empty and the description does not add any parameter-related information, which is fine given the absence of 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 the tool returns the names of defined load cases. It is specific enough to distinguish it from other ETABS tools, though it lacks an explicit verb like 'get' or 'list'.

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. Since it is a simple getter, the lack of usage context is somewhat acceptable, but it could mention that it is read-only or contrast with write operations.

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 discloses that the tool returns combinations and optionally their cases/factors, but does not state whether it is a read-only operation, any side effects, or performance implications. This is minimal 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 description is a single concise sentence that immediately conveys the core purpose and the optional parameter. It is front-loaded and contains no filler.

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

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

Given the tool's simplicity (one optional parameter) and the presence of an output schema, the description covers the essential purpose and parameter effect. It lacks explicit usage guidance, but for a straightforward read tool, it is reasonably 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?

Schema description coverage is 0%, so the description must explain the parameter. It does clarify that include_cases controls whether to include the cases and factors, which adds meaning beyond the bare boolean type. However, it does not elaborate on the default behavior or the exact structure of the returned data, so it only partially compensates for the lack of 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 states the resource (load combinations) and indicates it optionally includes the constituent cases and factors, but does not explicitly state the action (e.g., list, retrieve). It distinguishes from etabs_load_cases by referencing combinations, but without naming alternatives or specifying the verb, it remains somewhat 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 other ETABS tools like etabs_load_cases or etabs_load_patterns. The description does not provide context for selection or mention any exclusions.

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. It only states a noun phrase and does not disclose whether the tool is read-only, what it returns, or any side effects. This is a significant gap for a tool that likely queries model data.

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 phrase, but it is under-specified rather than concise. It does not earn its place by providing useful operational detail; it simply names the concept.

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?

Although the tool has no parameters and an output schema exists, the description fails to state the operation or differentiate from sibling load-related tools. An agent would struggle to know when to call this versus etabs_load_cases or etabs_load_combinations.

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

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

There are zero parameters, so the schema has no parameter descriptions to cover. The description adds no parameter meaning, but baseline 4 is appropriate because there is nothing to explain about 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 names the resource (load patterns) and mentions attributes (type, self-weight multiplier), but lacks an explicit verb like 'list' or 'retrieve'. It is not a tautology, but the action is implied rather than stated, making it somewhat 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?

No guidance is given on when to use this tool versus siblings such as etabs_load_cases or etabs_load_combinations. There is no context about selection criteria or exclusions.

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 says nothing about whether this is a read-only operation, whether it mutates the model, what it returns, or how it behaves. The passive noun phrase 'Materiales definidos' does not disclose any actual 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 very short with no filler or redundant content, and it front-loads the core resource. It earns its place, though it could have been structured as a clear action sentence without adding 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?

Even though the tool has no parameters and an output schema exists, the description still fails to make the operation explicit. An agent cannot confidently determine whether this tool lists existing materials or defines new ones, and no mention is made of how it relates to the define-material siblings.

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

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

The tool has zero parameters and an empty input schema, so there is nothing for the description to clarify about argument semantics. This matches the baseline of 4 for parameter-free tools.

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

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

The description identifies the resource (materials) and two attributes (type and specific weight), but it is a noun phrase rather than a sentence with an explicit verb. It does not clearly state whether the tool lists, retrieves, or defines materials, and it does not distinguish itself from siblings like etabs_define_concrete_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 given about when to use this tool instead of the many related sibling tools such as etabs_define_concrete_material or etabs_define_rectangular_section. The description offers no context, prerequisites, or exclusions.

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, and the description does not state whether the tool is read-only or has side effects. Since it appears to be a query tool, the lack of explicit non-destructive assurance leaves behavioral transparency weak.

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 that conveys the essential information without any fluff or redundancy. It is perfectly concise and well-structured.

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

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

For an expert user, the description provides enough information to understand what the tool returns and when it applies. However, it lacks details about the output format, units, or any limitations, making it only minimally 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?

There are zero parameters, so there is nothing to explain. The description still adds context by indicating the data source (executed analysis), which is useful for understanding the tool's scope.

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 that the tool provides modal periods and frequencies of the executed analysis, giving a clear sense of the tool's function. However, it lacks an explicit verb like 'returns' or 'gets', which slightly reduces 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?

The phrase 'del analisis ejecutado' implies it should be used after running an analysis, but there is no explicit guidance on when to choose this tool over alternatives, nor any mention of prerequisites or context for use.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It states it returns model data, which clearly implies a read-only operation, but it does not explicitly state that it does not modify the model or that it requires an open model (mentioned indirectly via 'modelo abierto'). The lack of explicit non-destructive assurance and potential failure condition (no open model) is a minor gap, but the description is adequate for a simple info getter.

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

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

A single, concise sentence that fully conveys the tool's purpose. No filler or redundancy, and the core information is front-loaded.

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 all essential aspects for a no-parameter info tool: it lists the specific data fields returned (file, version, units, analysis status). An output schema exists, so the description does not need to explain return formats. For its low complexity, nothing critical is missing.

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

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

The tool has zero parameters, so the input schema is trivially complete (100% coverage). There is nothing for the description to add about parameter meanings. Baseline for zero parameters is 4, and the description adds no extraneous parameter information.

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

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

The description clearly states the tool provides data about the open model (file, ETABS version, units, analysis status) with a specific verb and resource. It distinguishes from siblings like etabs_set_units (which modifies units) by implying read-only info retrieval, though it does not explicitly name an alternative.

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 alternatives, nor any exclusions. It does not mention prerequisites like an open model or suggest other tools for related operations. The context is implicit from the name and description, but no explicit usage direction 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 and the description does not disclose any side effects, such as whether it replaces the current model, requires an active connection, or affects unsaved work. This is a critical gap for a potentially destructive action.

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

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

Single concise sentence with no unnecessary words.

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

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

The description lacks essential context about the operation's broader effects, such as interaction with the current model state, file handling, and return value.

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 single 'units' parameter is undefined in the schema and not mentioned in the description, leaving its purpose, allowed values, and impact 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 clearly states it creates an empty model without predefined axes or levels, specifying the action and resource. It lacks explicit differentiation from siblings but the added detail helps distinguish it from a standard new model.

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

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

The description does not provide guidance on when to use this tool versus alternatives like etabs_new_model, nor does it mention prerequisites or conditions for use.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavior. It clearly states that the tool discards the open model without saving, a critical destructive trait. This is essential information, though it does not cover other potential behaviors like unit reset or return format.

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 two sentences with zero redundancy. The first sentence states the core function, and the second delivers a crucial warning. It is front-loaded and efficient, with every word earning its place.

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

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

The description covers the primary purpose and the key destructive warning, but it is incomplete for a tool with 8 parameters. It does not explain parameter meanings, nor does it mention the output schema or any post-creation behavior. An agent would need additional context to correctly configure the model parameters.

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 provides no explanation of the 8 parameters. While some names like 'stories' and 'spacing_x' are self-explanatory, others like 'bottom_story_height' and 'units' are not clarified. The description adds no semantic value beyond the schema's basic 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 the verb 'Crea' (creates) and the resource 'un modelo nuevo' (a new model) with a regular grid and indicated levels. It clearly conveys the tool's function, but does not explicitly differentiate it from sibling etabs_new_blank_model, relying on the 'regular grid' and 'levels' detail to imply 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 provides a clear prerequisite: save the current model before using this tool, because it discards the open model without saving. This is explicit guidance on when to use it (after saving) and implicitly warns against using it without saving, though it does not mention alternatives like etabs_new_blank_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. It only states that it opens a file, without mentioning side effects (e.g., overwriting the current model), error handling for missing files, prerequisites like an active ETABS connection, or the return value. 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, concise sentence with no filler. It is appropriately front-loaded and every word 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?

Despite having an output schema, the description is minimal. It does not disclose what happens after opening (e.g., model loaded into memory), whether it requires prior connection, or what the tool returns. Given the simple operation but the lack of annotations, the description is incomplete for an agent to call it safely and effectively.

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

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

The single 'path' parameter is a string with no schema description (coverage 0%). The description adds no extra meaning beyond implying the path points to a .EDB file; it does not explain required format, validation, or examples. The description fails to compensate for the schema's lack of detail.

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 'Abre un archivo .EDB existente' clearly states the verb (open) and the resource (an existing .EDB file). It distinguishes itself from siblings like etabs_new_model and etabs_save_model by implying an existing file operation.

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 this tool (when opening an existing model) but provides no explicit alternatives or when-not-to-use conditions. It does not reference sibling tools like etabs_new_model to guide selection.

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

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

With no annotations, the description does not disclose side effects, read-only behavior, pagination, or defaults for limit/offset, leaving the tool's behavior largely implicit.

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 brief and free of filler, but it is too sparse to fully communicate the tool's purpose and behavior.

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 gives the output fields but omits parameter meanings, pagination semantics, and any relationship to other ETABS tools, so it is not complete enough for reliable use.

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 three parameters (limit, story, offset) are not described in the schema or description; their roles as pagination and story-filter controls are only inferable from 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 names the resource ('Nudos') and the data fields returned (coordinates, label, level), but lacks an explicit verb like 'list' or 'get' to state the action.

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 sibling tools such as etabs_frames or etabs_stories, nor any indication of intended use cases.

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 the action but does not mention failure modes (e.g., if no instance is open), side effects, or whether the operation is safe or reversible. This is insufficient for an agent to anticipate outcomes.

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 redundancy. It front-loads the core action and is appropriately sized for a simple reconnection operation.

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 and has an output schema, so return values are covered. However, the description lacks context about preconditions (e.g., must have an open ETABS instance) or behavior when the server is already attached. Given the simplicity, it is partially complete but not fully.

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

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

There are zero parameters, so the baseline of 4 applies. The description does not need to add parameter-specific semantics since none exist.

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

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

The description clearly states the action ('re-attach the server to the open ETABS instance') with a specific verb and resource. It is distinct from all sibling tools, which focus on modeling, analysis, or data retrieval, so an agent can easily tell this is the reconnection tool.

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, no mention of prerequisites (e.g., having an open ETABS instance or a prior connection), and no alternatives. It simply states the function without context, so an agent has no basis to decide between this and other tools.

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

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

With no annotations, the description must carry the transparency burden. It mentions refreshing to see changes, implying a non-destructive UI update, but does not explicitly state side effects or safety. The lack of detail on potential impacts (e.g., unsaved work) leaves some 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 a single, concise sentence that directly communicates the tool's function and purpose. It avoids unnecessary detail or repetition, making it highly efficient.

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 absence of parameters and output schema, the description sufficiently covers the tool's purpose and effect. It could be slightly more explicit about the non-persistence of changes (i.e., it only updates the view), but overall it provides adequate context for such a simple utility.

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

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

There are no parameters, so the description does not need to explain any. The absence of parameters is consistent with the tool's simple action, and the description adds value by clarifying the purpose without parameter complexity.

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

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

The description clearly states the tool refreshes ETABS windows to display recently created changes. It provides a specific action and purpose, distinguishing it from vague or tautological descriptions, though it could be more precise about what 'windows' entails.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or context. It implies usage after making changes but lacks explicit guidance on when this refresh is needed or how it compares to other 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?

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only states the action ('run analysis') but doesn't mention side effects, whether the model is modified, if it requires an unlocked model, or if results are overwritten. This is a significant gap for a tool that likely alters model 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 very concise—two short sentences with no fluff. The main action is front-loaded, and the parameter note follows logically. It's appropriately sized for a simple tool, though it could be slightly more informative without harming 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?

Despite having an output schema (which covers return values), the description lacks guidance on when to run the analysis, prerequisites (like an open model), and behavioral implications. For a tool that likely triggers a heavy computation and modifies results, this is incomplete. An agent would need to infer usage 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?

The description adds meaning to the 'cases' parameter by stating 'Con `cases` solo ejecuta esos casos', clarifying that providing cases restricts the analysis to those. However, it's minimal and doesn't explain the expected format of case names or the behavior when cases is null. Schema coverage is 0%, so the description partially compensates but not fully.

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

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

The description clearly states the tool's function: 'Corre el analisis' (runs the analysis). It specifies a verb (run) and a resource (analysis), and the mention of 'cases' adds a scoping detail. It distinguishes from sibling tools because none of the others are named for analysis execution, though it doesn't 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?

The description provides guidance on the 'cases' parameter (only runs those cases) but gives no overall context on when to use this tool versus others. It doesn't mention prerequisites like an open model or whether it should be called after setup. No exclusions or alternatives are named.

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

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

With no annotations, the description carries the full burden. It mentions that providing a path performs 'save as' and advises using an absolute .edb path, but it does not disclose side effects such as overwriting an existing file or behavior when path is omitted.

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

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

The description is extremely concise—two short sentences—and immediately conveys the core purpose. No filler or 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?

For a simple save operation, the description covers the main action and the path variant, but it omits explicit mention that the tool saves the current model, potential errors, or output details. It is adequate but not richly 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 single 'path' parameter is described as enabling 'save as', which adds meaning beyond the raw schema. However, it does not clarify the default behavior when path is not provided, leaving part of the semantics ambiguous.

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

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

The description clearly states the tool saves the model, identifying the action and resource. It is distinct from sibling tools like open_model or new_model, though it does not explicitly mention 'current model'.

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 alternatives, and there is no mention of prerequisites (e.g., an open model). The path option is mentioned but not framed within a 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 and the description does not indicate whether the tool mutates model state (e.g., changes the active output selection) or is a pure read operation. The verb 'selecciona' suggests a state change, but side effects are not disclosed.

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 to the point, consisting of a single sentence with no unnecessary detail. However, it lacks any structural breakdown or related information that might help with understanding parameter usage.

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 adequate for a simple selection tool, but it does not specify whether both parameters can be provided simultaneously, what happens when one is omitted, or whether there is any confirmation of success. This leaves some ambiguity for the agent.

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

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

The schema provides no descriptions for the parameters, and the description does not elaborate on expected values (e.g., case/combination names) or the relationship between the two parameters. The parameter names are somewhat self-explanatory but additional context would be needed for correct usage.

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

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

The description clearly states the tool's purpose: selecting cases and combinations for result queries. It is distinct from sibling tools that define or run load cases/combinations, though it does not explicitly name 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?

No explicit guidance on when to use this tool versus alternatives. It is implied that it should be used before consulting results, but this is not stated nor are any prerequisites (e.g., after running analysis) mentioned.

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 mentions the default restraint (fixed), but does not disclose that this is a mutation operation, whether it overwrites existing restraints, or whether the point must exist. The effect of item_type is also unexplained.

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

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

The description is a single concise sentence that front-loads the verb and resource. It is efficient and free of filler, though it could benefit from a bit more structure to separate parameter explanations.

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 mutation tool with 3 parameters, no annotations, and an output schema not shown, the description is incomplete. It does not explain item_type, the behavior when restraints is null, potential side effects, or prerequisites. An agent would lack critical information to call it 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%, so the description must compensate. It partially explains the restraints array by listing the degrees of freedom, but does not clarify that it is a boolean array or what true/false means. The item_type parameter is entirely omitted, and the point parameter is only implied by 'nudo' without format details.

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

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

The description clearly states the verb 'Asigna' (assigns) and the resource 'restricciones a un nudo' (restraints to a node), and explicitly lists the degrees of freedom [U1, U2, U3, R1, R2, R3] and the default behavior (fixed). It is specific and distinguishable from sibling tools, which focus on other ETABS entities.

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, nor does it mention any prerequisites (e.g., point creation) or when not to use it. It simply states what it does without contextualizing its place in a workflow.

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

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

The description only says 'define', which implies a mutation, but it does not disclose whether existing stories are overwritten, if the model must be unlocked, or if the arrays must have matching lengths. No annotations are provided, so the description carries the full burden and fails to convey these behavioral aspects.

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

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

The description is a single, concise sentence that front-loads the action verb and clearly states the object. It avoids unnecessary detail and is easy 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?

Given the tool has 5 parameters (including optional ones) and an output schema, the description is insufficient. It omits key context about optional parameters, their interactions, and any return values or side effects. This makes the tool difficult to use correctly without additional documentation.

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 lists 5 parameters, but the description only clarifies 'names' and 'heights' (via 'niveles' and 'altura'). It does not explain the purpose or effect of `similar_to`, `base_elevation`, or `master_stories`, leaving 3 out of 5 parameters undocumented. Since schema description coverage is 0%, the description must compensate, but it does not.

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 verb 'Define' clearly indicates a setter action for story levels, and the resource 'stories' is specific. The phrase 'de abajo hacia arriba' (from bottom to top) adds ordering context, distinguishing it from the sibling tool `etabs_stories` which likely queries or retrieves stories.

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

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

The description provides no guidance on when to use this tool versus alternatives like `etabs_stories` (which may be a getter) or other story-related tools. There is no mention of prerequisites, such as having an open model or being in a specific unit system.

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 does disclose a key trait: the tool only affects value reporting and does not modify the model. However, it omits other potentially relevant behaviors such as persistence (session vs. model), scope, or whether it requires an open model. The disclosure is helpful but not exhaustive.

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 exceptionally concise, consisting of two short sentences with no redundant phrasing. The action is front-loaded, and the critical side effect (no model modification) is clearly stated. Every word contributes to understanding.

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 setter with a single parameter, the description covers the primary purpose and the most important behavioral note (non-modification of the model). It does not mention the return value or prerequisites like an open model, but these are less critical for a straightforward setter. Overall, it is sufficiently complete for the agent to use 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?

The schema provides zero description coverage for the 'units' parameter, so the description must compensate. It offers two example values ('Ton_m_C', 'kN_m_C') that hint at the expected format, but it does not enumerate the full set of acceptable units or explain the naming convention. This gives the agent a starting point but leaves ambiguity about allowed values.

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

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

The description clearly states the tool's function: changing presentation units for reading data, with concrete examples ('Ton_m_C', 'kN_m_C'). It distinguishes itself from sibling getters and model-modification tools by explicitly focusing on unit presentation, making its purpose unambiguous.

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

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

The description provides no guidance on when to use this tool relative to alternatives, nor does it mention that it should be invoked before reading data or that it affects subsequent queries. There are no exclusions or comparisons to sibling tools, leaving the agent to infer 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?

Without annotations, the description carries the full burden. It states the action 'list' but does not explicitly disclose whether it is read-only, requires an open model, or has 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, concise sentence with no unnecessary words.

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

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

The description lacks details about the output format, units, or ordering of the listed stories. Given no output schema is provided, this information is missing.

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

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

There are no input parameters, so the description has nothing to add. The absence of parameters is self-explanatory.

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

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

The description clearly states the verb 'list' and the resource 'levels' with their elevation and height. It is distinct from sibling tools like etabs_set_stories which modifies 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?

No guidance is provided on when to use this tool versus alternatives such as etabs_set_stories or etabs_story_drifts. The description does not mention prerequisites or 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?

With no annotations, the description carries the full burden of behavioral disclosure. It only states what the tool provides but does not mention whether it requires an unlocked model, if it is read-only, or what the output structure is (though output schema exists). The lack of any side-effect or state information 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, efficient sentence with no filler words. It is front-loaded with the core purpose. However, it is so terse that it sacrifices necessary context, but as a standalone statement it is concise.

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

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

Given the tool has no parameters and an output schema exists, the description's brevity might be tolerated, but it fails to explain the 'selected' prerequisite and provides no usage context among many sibling result tools. It is incomplete for an agent to know when to invoke this tool confidently.

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

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

The tool has zero parameters, so the schema imposes no burden. The description adds contextual meaning by referencing 'selected cases/combinations,' implying reliance on prior selection state, which is useful. However, it does not explain how selection is made, but since no parameters exist, this is acceptable.

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 tool provides story drifts per level for selected cases/combinations, which is a specific resource and distinguishes it from sibling result tools like base reactions or modal periods. However, it lacks a verb explicitly indicating the action (e.g., 'get' or 'retrieve'), and the meaning of 'selected' is ambiguous.

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. There is no mention of prerequisites (e.g., prior analysis or selecting cases), no exclusions, and no reference to sibling tools. The agent is left to infer 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?

The description explains the outcome (model becomes editable after analysis) and the context, but does not mention potential side effects or failure conditions. Given the simplicity of the action, this is adequate.

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

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

The description is a single concise sentence that conveys all necessary information without redundancy or fluff.

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 no parameters and a straightforward action, the description provides enough context (unlock after analysis to edit) and does not require additional details about output or edge cases.

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

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

There are no parameters, so the description does not need to explain any. The baseline for 0 params is 4, and the description is self-contained without missing parameter information.

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

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

The description clearly states the action (unlocks), the resource (the model), and the purpose (to continue editing after analysis). It is specific and distinguishes itself from other ETABS tools that don't mention unlocking.

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 implicitly provides a usage condition: after an analysis, before editing. This tells the agent when to invoke this tool, and no alternative unlocking tool exists among siblings, so no comparison is needed.

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