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

Annotations already declare the mutation profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the description carries little added behavioral weight. 'Returns new area names' merely restates return values that the output schema already covers, and it discloses nothing about permissions, model state requirements, or limits.

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 plus a short return note; appropriately sized with no filler. The core action is stated first, which helps an agent scan it quickly.

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?

Since an output schema exists, return values need not be explained. However, for a batch creation tool (up to 5000 areas) with zero schema description coverage and no annotations on model-state prerequisites, the definition leaves notable gaps around coordinate system selection and preconditions.

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 reported at 0%, so the description should compensate but does not: it never explains 'csys', the meaning of the 'areas' array, or the 'name' field. It only loosely implies the 'points' parameter via 'corner points', leaving key parameters undocumented in the description.

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

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

States a specific verb+resource: 'Draw floors, slabs and walls from corner points', and references the analogous GUI command (Draw > Floor/Wall). It is clear what the tool produces, though it does not explicitly contrast itself with siblings like etabs_add_frames or etabs_define_area_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?

The parenthetical '(like Draw > Floor/Wall)' gives implied usage context but there is no explicit statement of when to use this versus etabs_add_points or etabs_add_frames, nor any prerequisites such as needing the model unlocked or a valid area property defined.

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

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

Annotations cover the safety profile (readOnly=false, destructive=false, idempotent=false), and the description adds genuinely useful behavior beyond them: joints are created or merged automatically, and partial failures are reported per item. It stops short of noting any prerequisites (unlocked model, defined sections, active units).

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?

Three short sentences, front-loaded with the action and immediately followed by side effects and return behavior. No filler or restated name.

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

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

For a mutation tool with annotations and an output schema, the description covers the key agent-relevant facts: automatic joint merging, ordered return names, per-item failure reporting. The gap is the unexplained csys parameter and the absence of any precondition note (e.g., model state or unit system).

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?

Top-level schema description coverage is 0%: the 'csys' parameter is completely undocumented in both schema and description, and the 5000-item batch limit is unexplained. The description only implies start/end semantics via 'between two points' and says nothing about section assignment or coordinate-system behavior.

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

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

Names a specific verb and resource ('Draw beams, columns and braces between two points') and anchors it to the GUI equivalent 'Draw > Frame'. The phrase 'between two points' cleanly separates it from siblings like etabs_add_areas and etabs_add_points.

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 Draw-menu analogy implies the modeling context in which this tool applies, but there is no explicit when-to-use vs. alternatives guidance (e.g., when to prefer etabs_add_points plus a connect step, or how this interacts with etabs_assign_section). Usage is inferable but not stated.

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

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

The annotation block already declares the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the description's real contribution is the non-obvious de-duplication rule: existing joints at the same location are reused rather than duplicated. That is genuinely useful behavior an agent cannot infer from the schema. It stops short of explaining whether an unlock is required or how partial failures in a batch are reported. Note a mild tension with idempotentHint=false, though the description never claims repeated calls are no-ops, so this is not a contradiction.

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

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

One sentence, front-loaded with the action and scoped by the parenthetical. Nothing is padded and nothing needs reordering.

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 values need not be described, and annotations cover safety, which keeps this from being inadequate. But for a batch mutation accepting up to 5000 points, the description omits the csys interpretation, required model state, and batch/limit handling — meaningful gaps the agent must resolve elsewhere.

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?

Top-level schema description coverage is reported as 0%, so the description should compensate but does not: it says nothing about 'csys' (the coordinate system the supplied coordinates are interpreted in), which is the one parameter whose meaning is not self-evident. It gestures at 'coordinates' but adds no format, unit, or ordering detail beyond the nested schema text.

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?

A specific verb+resource ('Add joints at coordinates') that an agent can distinguish from etabs_add_frames and etabs_add_areas, which add different object types. It does not, however, explicitly call out those siblings or the scope limits that separate this from a generic point-creation call.

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 when-to-use guidance, no stated preconditions (e.g. model must be unlocked, units set via etabs_set_units), and no pointer to alternatives such as etabs_call_api for joints not expressible as coordinates. The parenthetical about reused joints is behavior, not usage guidance.

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 annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior, so the safety profile is fully covered. The description adds the useful content-level detail that the response includes run flags and lock state, but says nothing about staleness, refresh timing, or whether it reflects queued vs executed cases.

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

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

A single compact sentence that front-loads the main subject (per-case analysis status) before the secondary items. The '(not run / finished ...)' ellipsis is slightly sloppy but does convey the value domain efficiently.

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

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

With an output schema present, return-value detail need not be spelled out, and a zero-parameter read-only query is inherently simple. The remaining gap is routing context against the many status/analysis siblings, which keeps it short of a 5.

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 takes zero parameters, which per the rubric establishes a baseline of 4; there is nothing for the description to disambiguate. No parameter guidance is needed or missing here.

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

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

The description names a specific resource (per-case analysis status) and enumerates what it returns: status values, run flags, and model lock state. It is clearly a read-only inspection tool, distinct from run_analysis or job_status, though it never names those siblings to sharpen the distinction.

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

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

There is no when-to-use guidance: no statement about calling it before/after etabs_run_analysis, and no differentiation from the nearby etabs_job_status or etabs_status tools. The agent must infer its role from the name alone.

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

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

Annotations already declare the mutation profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false), so the safety burden is partly lifted. The description usefully discloses the dual effect (it both defines a diaphragm and assigns it) but says nothing about re-run behavior, whether an existing diaphragm with the same name is overwritten, or required 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?

A single well-formed sentence that front-loads the core action and stays free of padding. Minor redundancy in 'on the chosen stories' but nothing that should be cut.

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 values need not be described, and annotations cover non-destructiveness. Still, for a define+assign mutation the description omits model-state prerequisites and name-collision behavior, leaving meaningful 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?

Schema description coverage is only 33% (just 'stories'), so the description must compensate and partially does: 'rigid or semi-rigid' clarifies the semi_rigid flag and 'on the chosen stories' echoes the stories parameter. However, the 'name' parameter and its default 'D1', including any uniqueness or overwrite semantics, are left entirely unexplained.

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

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

The description names a specific verb pair (define and assign) and the precise resource (a rigid or semi-rigid diaphragm) plus its target (area/slab objects on chosen stories). It implicitly separates itself from other assign_* siblings like etabs_assign_section or etabs_assign_loads, though it never states that differentiation 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 on when to use this versus etabs_assign_section, etabs_set_mass_source, or other assignment tools, and no prerequisites are stated (model open, unlocked, slabs existing). The only usage hint, defaulting to 'all with slabs', is carried by the schema, not the description.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and idempotentHint=false, so the write semantics are partly covered. The description usefully adds that a missing label is auto-created and that remove detaches objects from groups, but it says nothing about whether existing label assignments are overwritten or what permissions are required.

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

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

A single front-loaded sentence with no filler; the core action and the create-if-missing behavior come first. It is efficient, though the UI reference adds little.

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 7 parameters, three mutually alternative targeting modes (group/names/selected), and a mutation side effect, the description is too thin. An output schema exists so return values need no explanation, but the targeting semantics and overwrite behavior are missing.

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

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

Schema description coverage is only 43%, and the description does not compensate: the 'group, pier or spandrel' phrasing merely restates the label_type enum, leaving labels, names, selected, and object_kind unexplained. An agent cannot tell from this how to target objects.

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

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

States a specific verb (assign) and resource (group/pier/spandrel label), plus the side effect that the label is created if missing. It reads clearly against siblings like etabs_assign_section or etabs_assign_loads, though it does not explicitly name how it differs from 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?

Only a UI analogy ('like Assign > ... in ETABS') is given; there is no statement of when to use this versus other assignment tools, no prerequisites, and no guidance on choosing between the group/names/selected targeting modes.

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

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

Annotations declare the mutation profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the safety burden is partly lifted, and the description adds genuinely useful non-annotation context: values are interpreted in present units and 'gravity' resolves to global -Z. It does not mention the replace-vs-add behavior on existing loads, which is important behavioral context 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?

Two tight sentences with zero filler; the core purpose and menu mapping come first, followed by the units/direction conventions. Nothing is redundant with the title or schema.

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 values need not be described, and annotations cover the safety profile. For a multi-kind nested schema in a 55-tool surface, the description covers what loads and units/direction mean, but omits the load-pattern prerequisite and the replace-vs-add implication, leaving a small 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?

Top-level schema description coverage is reported at 0% for the single 'loads' parameter, so the description should compensate, and it only partially does: the units convention and gravity semantics are relevant to the 'value' and 'direction' fields, but the array structure, 'pattern' requirement, and 'replace' default are not addressed. The nested LoadInput fields do carry their own descriptions, which limits the penalty.

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 gives a specific verb+resource ('Assign loads') and even maps it to the ETABS menu path (Assign > Frame/Shell/Joint Loads), then enumerates the load types it handles (distributed/point on frames, uniform on areas, forces/moments on joints). This clearly separates it from the define_* siblings such as etabs_define_load_patterns or etabs_define_wind_load, though it never names 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?

Usage is only implied by the parenthetical menu mapping and the list of supported load kinds; there is no explicit statement of when to choose this over etabs_define_load_patterns, etabs_define_seismic_load, or etabs_list_load_definitions. An agent can infer that this applies loads onto already-existing objects, but the prerequisite (a load pattern must first exist) and any exclusions are left unstated.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds only the UI menu path, not behavioral context such as whether existing assignments are overwritten, what happens if the named section is undefined, or how names vs group vs selected selects the target objects.

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 the operation named first and a compact parenthetical for the UI equivalent. Nothing is redundant, though the brevity leaves the tool under-specified rather than optimized.

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 five-parameter model-mutating tool with 20% schema coverage, this description is far too thin. An output schema exists so return values needn't be explained, but the missing target-selection semantics (names/group/selected) and the missing define-before-assign prerequisite are real gaps for an agent trying to invoke this 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 only 20% (only 'section' is documented), so the description must compensate. It clarifies the frame-vs-area meaning of the kind/section pairing, but says nothing about group, names, or selected — three of five parameters are undocumented in both schema and description, including how target objects are chosen.

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

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

States a specific verb (Assign) and resource (frame section or area property), with the kind enum distinguishing frame vs area usage. The UI menu mapping (Assign > Frame > Section / Shell > Property) reinforces what operation this performs. It stops short of explicitly differentiating from the define_frame_section / define_area_section siblings, leaving the define-then-assign relationship implicit.

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 when-to-use guidance, no prerequisites, and no mention of alternatives. The agent must infer that a section/property must already exist (via define_frame_section or define_area_section) before this tool is called, and nothing states how names/group/selected scope interacts with the assignment.

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?

Adds genuinely useful return/error semantics not in the annotations: ByRef values surface under 'outputs' and a non-zero 'ret' signals rejection (ok=false). But it discloses nothing about the destructive/permission surface the annotations flag (destructiveHint=true, non-idempotent), and an output schema already exists so the return-format note partly overlaps structured 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?

Three tight sentences, front-loaded with the core purpose, then validation behavior, then the error convention. Every sentence carries information; nothing is padded.

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 catch-all API-invocation tool this is adequate but thin: it never points the agent to etabs_search_api/etabs_describe_api for discovering method paths, nor tells it when to reach for typed tools or the batch variant, which is the main selection question for this tool family.

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

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

Schema description coverage is 100%, so all four parameters (path, args, confirm, max_items) are already documented in the schema. The description adds no format, syntax, or naming-convention detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a concrete verb+resource: call any ETABS API method, with the escape-hatch nature made explicit. However, it never distinguishes itself from siblings like etabs_call_api_batch or etabs_describe_api, so the agent gets no help routing among the API-level tools.

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

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

No guidance on when to prefer this generic escape hatch over the many typed siblings (etabs_set_stories, etabs_add_points, etc.) or the batch variant. The only conditional text is borrowed from the schema's confirm field, not the description itself.

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

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

Annotations already disclose destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds behavioral details beyond annotations: calls run in order, each result is reported, and stop_on_error halts at the first failure. It does not describe what specifically gets destroyed, atomicity, or auth requirements, but it adds meaningful context about ordering and failure handling.

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

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

Two compact sentences with no wasted words. The primary purpose is front-loaded, followed by key behavioral details. Every sentence contributes directly to understanding the tool.

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

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

The output schema means return values need not be explained. However, for a destructive batch tool, the description omits any mention of the confirm parameter or confirmation requirements, and does not clarify atomicity or what happens to successful calls when a later call fails. These are relevant gaps despite the schema providing some parameter descriptions.

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

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

Schema coverage is 67%, with confirm and stop_on_error documented in the schema. The description explains stop_on_error's behavior and implies ordered calls via 'in order', but it does not mention the confirm parameter at all. The description adds some meaning beyond the schema for one parameter but leaves confirm reliance entirely on structured data.

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

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

The description states a specific verb and resource: running several API calls in order in one round trip. It clearly conveys batch execution versus a single call, but it does not explicitly contrast with the sibling etabs_call_api tool. The purpose is clear enough for an agent to understand, though sibling differentiation is left implicit.

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 example '(for example, define and assign many properties)' implies a use case for batching, and 'in one round trip' hints at efficiency benefits. However, there is no explicit guidance on when to use this tool versus multiple etabs_call_api calls or other alternatives, and no exclusions or prerequisites are stated. Usage is implied rather than fully specified.

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

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

Annotations only declare it as a non-read-only, non-destructive, non-idempotent mutation. The description adds real context the annotations lack: it saves the model and keeps a labeled copy as a restore point, and that it requires an already-saved model. It doesn't cover failure behavior or whether labels must be unique, but it strengthens an otherwise sparse 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?

Two short, front-loaded sentences: the action first, then the restore pairing and prerequisite. No wasted text; the analogy earns its place by conveying intent.

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 one-param tool with an output schema and clear annotations, this is nearly complete: what it does, how it's paired, and the prerequisite. Minor gap: it doesn't state what happens if the model is unsaved or if the label collides.

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?

Single param 'label' with 100% schema coverage including pattern and example. Description adds nothing about the label beyond what the schema already provides; baseline 3 applies.

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

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

Specific verb (save + copy as named checkpoint) and resource (model), with a concrete analogy ('an undo point before risky edits') that pins down intent and distinguishes it from etabs_save_model and etabs_restore_checkpoint.

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?

Explains purpose (undo point before risky edits) and names the paired tool etabs_restore_checkpoint. It also states the prerequisite 'Needs a saved model.' It does not explicitly say when to prefer etabs_save_model instead, but the usage context is clear.

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

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

Annotations already cover the safety profile (readOnlyHint, idempotentHint, non-destructive), so the bar is lower. The description adds real value beyond them: it is a batched single-call operation and it discloses the return content per check (clause, governing numbers, pass/fail). It stops short of stating prerequisites such as requiring a completed analysis run.

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

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

Two dense sentences, front-loaded with the action and the check inventory, with no filler. Every clause maps to an actual check or output the tool produces.

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-format explanation is not owed, and the description still summarizes it. For a 13-parameter, no-required-param read tool the coverage is adequate but incomplete: it doesn't say which parameters apply to which checks, that all default to sensible values, or that torsional/soft-story limits are two-element arrays.

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 only 38% across 13 parameters, so the description must carry weight, and it does partially: describing drift-vs-allowable, torsional irregularity, weight irregularity, modal mass participation and RS base shear vs ELF maps conceptually onto drift_limit, torsion_limits, weight_limit, modal_case/modal_target, and rs_case/elf_case/rs_target. However, it never names these parameters and leaves rs_direction, drift_amplification, checks and cases unaddressed, so an agent still has to read the schema.

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

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

States a precise verb+resource (run standard post-analysis checks) and enumerates the six checks, which map one-to-one onto the `checks` enum values (drift, torsion, soft_story, weight, modal_mass, rs_scaling). An agent can distinguish this from siblings like etabs_run_design or etabs_get_design_summary without opening any schema.

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

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

The phrase 'post-analysis checks' implies the model must already have been analyzed, which is useful context, but there is no explicit when-to-use guidance, no exclusions, and no pointer to alternatives (e.g., use etabs_get_design_summary for member design results, etabs_run_analysis first). Usage is inferable but not stated.

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

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

Annotations declare the safety profile (not read-only, not idempotent, non-destructive), so the description's job is to add operational context — and it does: a 10-30 s launch latency, auto attach-else-start semantics, and the recovery use case. It does not cover return shape or failure modes (e.g. what happens if the pid is stale), but the latency warning is genuinely useful information not available anywhere else.

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

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

Two tight sentences, zero filler: the first names the action and the exclusion rule, the second lists the three legitimate use cases, and the latency caveat is appended where it matters.

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

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

With an output schema present, return values need no explanation, and the annotations plus the 7 fully documented parameters mean the agent has everything required to invoke it. The only thin spot is what happens on connection failure or how long 'reconnect' blocks, which the description leaves implicit.

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

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

Schema description coverage is 100% and every parameter already has a self-contained description (pid cross-references etabs_list_installations, mode enumerates attach/start/auto, instance explains 'b' as a second instance). The description largely restates the schema's 'auto' semantics and adds no syntax or format detail beyond it, so the baseline 3 applies.

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

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

States a specific verb+resource ('Connect to ETABS') and immediately distinguishes itself from the ~60 sibling tools by noting they connect automatically with mode 'auto'. The agent can tell without opening a schema that this tool is the exception path, not the normal entry point.

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?

Gives explicit when-to-call conditions: choose a specific instance or version, drive several instances, or recover after ETABS was closed. It also names the default behavior that makes this tool unnecessary in the normal case, which is exactly the when-not guidance an agent needs.

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

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

Annotations already declare this is a non-read-only, non-idempotent mutation, so the safety profile is covered. The description adds nothing behavioral beyond the menu path: it does not say whether redefining an existing section overwrites or errors (relevant given idempotentHint=false), nor what permissions or model state are required.

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

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

A single front-loaded sentence with no waste. It is efficient, though the extreme brevity is arguably under-specification rather than pure 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?

The output schema exists, so return values need not be explained, but for a 6-parameter definition tool at 17% schema coverage the description is far too thin. It omits validation rules, default behavior, and the interaction with later assign-section calls that an agent needs 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 only 17% (just 'thickness' documented), so the description must compensate but instead adds zero parameter detail. It never explains name, material, kind/slab_type/shell_type semantics or the units convention for thickness, leaving 5 of 6 parameters undocumented everywhere.

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

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

States a specific verb ('Define') and resource ('slab or wall property'), and the parenthetical maps it to the concrete ETABS menu path. This implicitly separates it from etabs_define_frame_section and etabs_define_material, though it never names a sibling to disambiguate explicitly.

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

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

The description gives no when-to-use guidance, no prerequisites, and no alternatives. It only tells the agent that this creates a slab/wall section property, leaving the agent to infer that a section must exist before etabs_assign_section is useful.

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

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

Annotations declare openWorldHint=false, idempotentHint=false and destructiveHint=false, so the mutation/repeatability profile is already carried structurally. The description adds limited extra behavior: it clarifies that default combos follow the 'active design codes', but says nothing about whether redefining a combo with an existing name overwrites it or duplicates it — a meaningful gap for a non-idempotent write 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?

One front-loaded sentence covering both capabilities with no filler, redundancy, or restatement of the tool name. Every clause 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?

With an output schema present, return values need no explanation, and parameters are fully schema-documented. However, for a non-idempotent write tool the description omits overwrite/duplicate behavior for existing combination names and any precondition check, leaving the agent guessing about side effects.

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

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

Schema description coverage is 100%, so baseline is 3. The description maps its two sentences onto the two top-level parameters (combinations vs add_default_design_combos), which is helpful framing, but it adds no detail about structure, required fields, or the scale-factor/type semantics that the schema already defines.

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

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

States a specific verb (define) plus resource (load combinations), and scopes the tool precisely: it creates combinations from load cases/other combinations OR generates code default design combos. The resource name distinguishes it cleanly from siblings like etabs_define_load_patterns and etabs_define_seismic_load, and the parenthetical UI path (Define > Load Combinations) removes 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?

The 'and/or' phrasing implies both modes are optional and combinable, which is genuine usage guidance, but there is no explicit when-to-use/when-not, no stated prerequisites (e.g. load cases must already exist), and no routing to alternatives such as etabs_define_load_patterns when the user actually wants patterns.

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

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

Annotations already declare this is a non-read-only, non-destructive, non-idempotent, closed-world mutation, so the safety profile is covered. The description adds a genuinely useful behavioral fact — dimensions are interpreted in the model's present length units, coupling it to etabs_set_units — but says nothing about overwrite-on-name-collision or validation failures.

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

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

Two sentences, zero padding, with the core purpose front-loaded and the units caveat last. Every clause carries information an agent needs.

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

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

For an 11-parameter creation tool with an output schema available and annotations covering the mutation profile, the description adequately frames the two modes and the units behavior. It stops short of the prerequisites and collision semantics an agent would want before a mutating call, but nothing essential to selecting the tool 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?

Schema description coverage is 73% and each dimension parameter already carries its own t2/t3 explanation; the description only adds the mode framing (which params belong to parametric vs. library shapes) and the units convention. That is real but marginal added meaning over an already well-documented schema, so baseline 3 fits.

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

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

States a specific verb+resource ('Define a frame section') and immediately splits it into its two operational modes: parametric concrete/steel shapes versus a library-imported steel shape. That is enough to separate it from etabs_define_area_section and etabs_define_material, though no sibling is named explicitly.

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

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

The two modes (parametric vs. 'from_library') are described, which implicitly tells the agent which path to take for a given need, but there is no explicit when-to-use / when-not-to-use guidance and no stated prerequisite (e.g. the material must already exist, or section must precede etabs_assign_section).

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

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

Annotations already declare readOnly=false, idempotent=false, destructive=false, so the safety profile is covered. The description adds genuine behavioral context by revealing that each pattern may also spawn a linear static load case, but it omits re-run/replace semantics, permission or unlock requirements, and side effects on existing patterns.

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 clean, front-loaded sentence with no filler, mapped to the UI path. However, for a non-idempotent mutation tool it is arguably too terse — the brevity comes at the cost of missing preconditions rather than being an efficient summary of complete 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?

An output schema exists so return values need no explanation, but as a write operation with no annotations covering mutation behavior in depth, the description should state preconditions (connected instance, unlocked model) and effects on existing definitions. Those are absent, and the sole top-level parameter is left undescribed.

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?

Top-level schema coverage is effectively 0% — the 'patterns' array is undocumented — and the description only gestures at the optional load-case behavior. Nested fields (type, add_analysis_case) do carry inline descriptions, but the description does not clarify the required 'name', the array-of-objects structure, or the self-weight multiplier.

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

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

States a specific verb and resource ('Define load patterns') and even maps it to the ETABS UI path, which helps distinguish it from siblings like etabs_define_seismic_load, etabs_define_wind_load, and etabs_define_combinations. The clause about optionally creating a matching linear static load case adds useful scope, though it doesn't explicitly contrast with those siblings.

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 when-to-use guidance, prerequisites, or alternatives are given. It doesn't mention that the model must be connected and unlocked, nor when to prefer this over the seismic/wind/combination definitions. The agent must infer all of this from sibling names.

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

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

Annotations already establish this as a non-read-only, non-destructive, non-idempotent, closed-world mutation, so the safety profile is covered. The description usefully notes that library inputs mirror the 'Add Material' dialog, but it omits what happens if the material name already exists, whether overwrite/error occurs, and any permission or model-state requirements.

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, front-loaded with the core action, that covers both modes without redundancy. No filler and no restatement of the tool name.

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

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

For a 12-parameter mutation with an output schema, the description covers the essential branching but is thin on preconditions, duplicate-name behavior, and where it sits in the define-then-assign workflow. Adequate as a minimum-viable definition, with clear gaps an agent would hit in practice.

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 groups parameters by creation mode (library vs custom), which clarifies intent, but the schema already labels region/standard/grade as 'Library material' and elastic_modulus as 'Custom material'. Beyond that grouping, 12 parameters at 67% coverage leave defaults and interactions (poisson_ratio, thermal_coefficient, fu default of 1.25 fy, mixing library and custom fields) unexplained.

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

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

The description states a specific verb and resource ('Define a material') and, unusually, explains the two distinct creation paths: library (region + standard + grade) and custom isotropic (E, weight, strength). It does not, however, position itself against nearby siblings such as etabs_define_frame_section or etabs_define_area_section, which consume materials once defined.

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 gives a usable branch between library and custom input but frames this as parameter selection rather than tool-selection guidance. There is no statement of prerequisites (an open/unlocked model, units) or of when-not to call it, so an agent must infer the workflow position.

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

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

Annotations declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so it's a non-destructive but non-idempotent mutation. The description adds nothing beyond that: no mention of prerequisites (existing modal case), side effects (creates two model objects), or what happens on re-invocation with the same case name.

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

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

Single efficient sentence, front-loaded with the verb and both created artifacts. No waste, though extremely sparse given 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?

A 13-parameter mutation tool with no schema descriptions, no parameter guidance in the description, and no behavioral disclosure. The presence of an output schema helps slightly, but the definition is far too thin for an agent to invoke correctly without guessing at ASCE 7-16 parameter meanings.

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

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

Schema coverage is only 8% (only scale_factor has a description). With 13 parameters and near-zero schema documentation, the description must compensate but instead adds nothing—no meaning for R, Ss, S1, Tl, site_class, direction, eccentricity, case_name, or function_name.

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

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

States a specific verb (define) and two resources (ASCE 7-16 response spectrum function and a response-spectrum load case). Clearly distinct from siblings like etabs_define_seismic_load and etabs_scale_response_spectrum, though it doesn't explicitly name those relationships.

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?

Implied usage: call this to create a response spectrum function plus load case before scaling (etabs_scale_response_spectrum) or running analysis. No explicit when/when-not guidance, prerequisites (e.g., modal case must exist), or named alternatives.

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

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

Annotations already disclose mutation (readOnlyHint=false), non-idempotency, non-destructiveness, and closed-world behavior. The description adds useful side-effect context by stating it creates both the Quake pattern and its load case, but it omits permissions, prerequisites, and the consequence of repeated calls despite non-idempotency.

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

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

Two sentences with zero filler; the core action and ETABS UI location are front-loaded, and the second sentence adds the concrete side effect of creating a pattern and load case.

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 and annotations cover the safety profile, so return values and mutation semantics need not be repeated. However, for a 16-parameter tool with all-optional arguments, the description omits prerequisites (unlocked model, units, existing stories) and default/interaction behavior, leaving meaningful gaps.

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

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

Schema description coverage is 69%, leaving parameters like name, importance, user_period, eccentricity, and site_class without schema descriptions. The tool description provides no parameter-level meaning, default behavior, or interaction guidance (e.g., period source vs ct_type/user_period), so it does not compensate for the uncovered 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?

States a specific verb ('Define'), resource ('ASCE 7-16 equivalent-lateral-force seismic load pattern'), UI path, and side effect of creating the Quake pattern and load case. It is clear but does not name or distinguish itself from sibling tools like etabs_define_load_patterns, etabs_define_wind_load, or etabs_define_response_spectrum.

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 specific standard and load type imply the use case (defining an ASCE 7-16 ELF seismic pattern), but there is no explicit when-to-use guidance, no when-not conditions, and no mention of alternatives such as the generic load pattern or response spectrum tools. Prerequisites like an unlocked model are absent.

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

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

Annotations already declare it is a non-destructive write (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false). The description adds that it creates an automatic pattern and explains the code/fields mechanism, but does not cover auth needs, duplicate-handling, or side effects beyond what annotations imply.

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

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

Two sentences, front-loaded with purpose and the UI path, then a compact note on code parameterisation. No filler or redundancy.

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

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

For a 14-parameter write tool, the description is complete on the unique aspects (auto wind, ASCE vs other codes, UI path) and output schema covers return values. However, the low schema coverage on parameters means an agent lacks semantic detail for most inputs, leaving a moderate 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 36% (5 of 14 params). The description clarifies the relationship between 'code' and 'fields', which is useful, but leaves many parameters (kd, kzt, exposure, top_story, leeward_cp, gust_factor, windward_cp, bottom_story) without explanation in either schema or description. It only partially compensates for the low coverage.

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

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

States a specific verb 'Define' and resource 'automatic wind load pattern applied to diaphragms', plus the exact UI path. This distinguishes it from sibling load-definition tools like etabs_define_seismic_load and etabs_define_load_patterns.

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?

Gives context for the 'code' parameter and how to handle non-ASCE codes via 'fields', but does not explicitly say when to use this tool versus alternatives such as etabs_define_seismic_load or etabs_define_load_patterns. No exclusions or prerequisites are stated.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the agent knows this is an irreversible mutation. The description adds no behavioral context beyond that — nothing about the fact that deletion cannot be undone (that lives only in the schema's confirm param), what happens on partial failure, or whether an open model/selection is required.

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

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

A single front-loaded sentence with no filler; the verb, target objects, and targeting modes are all delivered in one pass.

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 destructive tool with annotations covering the safety profile and an output schema covering returns, the description is minimally adequate. It omits required-session state, the confirm gate behavior, and what happens when multiple targeting parameters are supplied simultaneously.

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 only 20% (confirm is the sole documented parameter), so the description must compensate. It does explain the three targeting parameters (names, group, selected) and the kind values, but leaves the interplay between group/names/selected and the precedence rules undocumented.

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

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

The description states a precise verb (Delete) and resource (frames, areas, points), and enumerates the three targeting modes. An agent can tell it apart from etabs_list_objects or etabs_select by the delete action and object kinds, though it never names a sibling alternative 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?

Usage is implied by the listing of three lookup modes (by name, by group, current selection), which tells the agent how to target objects. There is no guidance on when to prefer this over etabs_list_objects/etabs_find_objects for verification, nor any stated preconditions 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?

Annotations already declare readOnlyHint, idempotentHint and non-destructive behavior, so the bar is lower. The description still adds genuine value: it discloses that output 'Reflects the connected ETABS version' (output varies with connection state) and that a method's 'safety level' is reported, which is behavioral context not present in 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?

A single front-loaded sentence enumerating the three query modes with no filler. It is dense but every clause earns its place; slightly more structural separation of the modes could aid scanning, hence not a 5.

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

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

With an output schema present, return values need no explanation, and annotations cover the safety profile. The description covers all three query modes and the version-dependence caveat, leaving only minor gaps such as behavior on an unresolved/ambiguous path.

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

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

Schema description coverage is 100%, and the schema's own path description already gives the three accepted formats with examples. The description adds little beyond restating that path may be a method, interface, or enum, so the baseline 3 for schema-carried parameters is appropriate.

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

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

States specific verbs (show/list) against specific resources (method signature, interface methods/sub-interfaces, enum values) and enumerates what the signature output contains. An agent can immediately distinguish it from etabs_search_api and etabs_call_api without opening any schema.

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

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

The three modes are clearly mapped to input shapes (method path vs interface vs enum), which effectively tells the agent what it will get for a given path. It stops short of naming alternatives or stating when to prefer this over etabs_search_api, so it is clear context without explicit routing.

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

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

Annotations already declare the safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=false), so the bar is lower. The description adds useful context on what 'list' returns and the range of design categories, but says nothing about whether a 'set' persists to the model, whether it requires the model to be unlocked, or how it interacts with design runs. Adequate but thin beyond 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?

Two compact sentences that lead with the action triad and resource before expanding into behavior. The GUI breadcrumb wastes a few tokens but overall the text is front-loaded and efficient with no filler sentences.

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

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

With an output schema present, the description needn't explain return values, and annotations cover the safety profile. The action semantics and supported disciplines are covered, though missing unlock/permission prerequisites for a mutating 'set' leave a small gap for a write-capable tool.

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

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

Schema description coverage is 67%, with 'code' and 'kind' documented and 'action' carried by an enum. The description reinforces 'list' semantics and enumerates disciplines (steel, concrete, shear wall, slab, composite), though this enumeration actually exceeds the 'kind' enum values (steel, concrete, concrete_shell), which could mildly confuse the agent about valid inputs. It adds marginal meaning over the schema.

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

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

States a specific verb triad (Read, list, change) applied to a precise resource (design codes), and even pins the GUI location (Design > ... > View/Revise Preferences) plus the supported design disciplines. It is unambiguous what the tool governs, though it does not explicitly contrast itself with sibling tools like etabs_run_design or etabs_code_checks.

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

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

The description implies usage through the action labels and notes that 'list' returns every supported code, which helps the agent pick between get/set/list. However it never states when to reach for this tool versus the many design-related siblings, nor any prerequisites for changing codes. Usage is implied rather than spelled out.

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

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

Annotations declare readOnlyHint=false but destructiveHint=false, so the agent knows this is a non-destructive write. The description adds useful context beyond the annotations: it writes a Markdown file and returns both the text and the file. However, it does not state overwrite behavior if the target file already exists, nor any required model/analysis state, which matters for a file-writing 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?

Two tight sentences, front-loaded with the action verb and the output format, and the content list is efficiently compressed. No filler, though the trailing 'Returns the text and the file' is somewhat redundant with an existing output schema.

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 values need not be explained, and both parameters are documented in the schema. The remaining gap is operational context (preconditions such as a completed analysis/design run), which keeps this just short of full completeness for a report generator.

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

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

Schema coverage is 100%, so 'top' and 'path' are already fully documented in the schema. The description's phrase 'the design check with the most critical members' loosely maps to 'top' but adds no format or default detail. Baseline 3 applies when the schema carries the load.

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

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

The description states a specific verb and resource ('Write an engineering summary in Markdown') and enumerates exactly what the report contains (model, loads, analysis status, base reactions, modal periods, drifts, design check). An agent can tell it produces a document rather than raw data, but it never distinguishes itself from close siblings like etabs_get_design_summary or etabs_code_checks.

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 when-to-use guidance, no prerequisites (e.g. analysis/design must have run first), and no mention of alternatives. With so many sibling reporting tools in the list, the absence of routing guidance is a real gap.

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

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

Annotations declare readOnly=false, destructive=false, idempotent=false, but add no meaning on their own. The description supplies the key behavioral fact those annotations omit: open modal dialogs block the ETABS API, which explains why this otherwise odd tool exists and when it must be run. It does not say what closing does to unsaved state, but the non-destructive annotation covers safety.

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

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

Two tight sentences, front-loaded with the what and immediately followed by the why. No filler, no restating of the name.

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

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

With an output schema present, return values need not be described, and annotations plus the description cover safety and intent for a simple 2-param tool. The only residual gap is the undocumented action enum semantics, which the description only implies.

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

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

Schema coverage is 50%: the title parameter is documented ('close with no title closes all') but the action enum has no description in the schema. The description implies the list-vs-close distinction and the bulk-close case, but adds little beyond what the schema's title description already states, so it lands at baseline.

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

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

States a specific verb pair (list/close) and the resource (ETABS dialogs), which cleanly distinguishes it from every sibling. It also gives the causal motivation — a modal dialog blocks the API — so the agent understands what the tool is for.

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

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

Explicitly names the situations that call for it: 'close leftovers after etabs_menu or a design run.' That is a concrete when-to-use trigger tied to specific sibling tools, not vague guidance.

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

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

Annotations only flag destructiveHint=true; the description adds the crucial scope clarification that disconnecting does NOT exit ETABS by default, which meaningfully narrows the apparent blast radius. It does not disclose what happens to unsaved model state on plain disconnect or whether an active session is required, but the added context exceeds the annotation baseline.

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

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

Two terse sentences, front-loaded with the primary action and followed by the one behavioral caveat that matters. Nothing is redundant or padded.

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 values need not be explained, and the description covers the essential default versus close behavior. It leaves minor gaps around session-state requirements and interaction with the save/confirm parameters, but is sufficient to invoke correctly.

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

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

Schema coverage is 100%, so save and confirm are already fully documented in the schema, and the description only echoes close_etabs. Baseline 3 is appropriate since the description adds no syntax or default details beyond the structured fields.

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 gives a clear verb+resource ('Release the ETABS connection') that is unmistakably the inverse of the sibling etabs_connect, so an agent can select it without opening either schema. It stops short of naming or contrasting with siblings explicitly, keeping it below a 5.

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

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

Implicit usage is clear (call it to tear down a session), and the note that ETABS keeps running unless close_etabs is true gives a condition for the more aggressive variant. However, there is no explicit when-to-use/when-not guidance, no mention of prerequisites (e.g., pending jobs) or the counterpart etabs_connect.

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 explicitly states the tool can 'delete rows', and the schema exposes delete_where and replace_rows (a full-table overwrite), yet annotations declare destructiveHint=false, which in MCP means additive-only updates. This is a direct contradiction between the stated behavior and the structured safety signal. (The description's other useful additions, e.g. the apply/dry-run flow and the import-log return, do not offset it.)

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

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

Two front-loaded sentences with no filler; the core operation and the apply step come first. The trailing sentence about the import log is mildly redundant given an output schema exists, but the structure is otherwise tight.

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 7-parameter mutation tool with five edit modes, the description gives an adequate but incomplete picture: it omits the replace_rows full-table overwrite (the most destructive mode), says nothing about the editable-table prerequisite, and relies on the output schema for the return shape. Adequate minimum, with a notable 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 86%, so the schema already carries the parameter semantics (apply dry-run, match/set, append_rows, delete_where, replace_rows). The description only maps loosely onto change/append/delete and never mentions the replace-whole-table mode at all, adding little beyond the schema baseline.

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

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

States a specific verb and resource ('Edit a model table'), enumerates the operations (read, change/append/delete rows, apply), and frames it against the Interactive Database editor workflow. It implies but never names the read-only siblings (etabs_list_tables, etabs_get_table) that an agent must choose between, so it falls short of a 5.

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

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

Usage is only implied via the analogy to the Interactive Database editor and the 'then apply' workflow. There is no explicit when-to-use/when-not, no statement that table_key must be an editable table (that constraint lives only in the schema), and no routing away from etabs_get_table or etabs_call_api.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds that the output is paged text, but stays silent on the file-write side effect implied by 'path' and on any size/latency implications of a whole-model dump.

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

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

Two tight sentences, verb-first, with the completeness guarantee and audit use case front-loaded. No filler and no repetition of schema or annotation content.

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

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

An output schema exists, so return values need no explanation, and the description adequately conveys that the response is the full model definition rather than a subset. It could be slightly stronger by clarifying the file-write behavior of 'path', but nothing essential for correct invocation 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?

Schema coverage is 75% (max_chars is undocumented in the schema), so the baseline is 3. The description adds no parameter detail beyond a generic '(paged)' hint, leaving offset and the section-prefix filtering semantics to the schema.

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

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

Names a specific verb (export), resource (whole model), and format (.e2k text), and enumerates the covered content (stories, grids, materials, sections, objects, assignments, loads, cases). It reads as the 'complete dump' counterpart to etabs_model_overview, but never names that sibling explicitly, so it doesn't earn a 5.

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

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

'One read gives the complete definition... ideal for audits' supplies a clear use case and signals this is the exhaustive option rather than a summary view. There is no explicit when-not or named alternative (e.g., model_overview for a quick look), so it stops short of a 5.

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

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

Annotations only give a thin safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the description carries extra weight. It discloses the two non-obvious behaviors: results are reusable object names, and the call can mutate selection state ('can select them'), which explains why readOnlyHint is false for a 'find' operation.

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

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

A single tight sentence of purpose plus examples, followed by one clause on output and side effects. The purpose and scope are front-loaded and no sentence is 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?

An output schema exists, so return-value explanation is unnecessary, and the description covers the primary use cases, output reusability and the selection side effect. With 12 parameters at 58% documented coverage, a few gaps remain (limit semantics, kind enum behavior), but nothing critical for calling it correctly 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?

Schema coverage is only 58%, with kind, limit, max_ratio and stories undocumented in the schema. The description partially compensates by mapping examples to those params ('columns on Story3' → role+stories, 'longer than 8 m' → min_length, 'D/C over 0.9' → max_ratio, 'this box' → box), but leaves units formatting, default limit and pagination implications unaddressed.

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

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

States a specific verb+resource (find objects) and makes it concrete with four engineering-criteria examples (story, length, D/C, bounding box). It distinguishes itself from etabs_list_objects by being criteria-driven rather than a plain enumeration, though it never names that sibling explicitly.

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

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

The example queries imply when to reach for this tool (attribute/geometry/ratio-based search), but there is no explicit when-to-use-vs-alternative guidance. It does not say when to prefer this over etabs_list_objects or etabs_select, leaving the routing decision to inference.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the agent knows this is a mutating, non-reversible operation. The description adds the sequencing context (lateral loads then analysis) but does not itself warn that an open model is replaced or that confirm is required — that critical behavior lives only in the confirm schema 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?

Two sentences, front-loaded with the complete inventory of what gets built, followed by the next-step guidance. The long enumeration is dense but earns its place for a tool that performs roughly a dozen operations; nothing is wasted.

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

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

With an output schema present and rich annotations, the description need not explain return values. It covers scope and workflow well; the only real gap is that the model-replacement/confirm behavior is not surfaced in the description itself, though it is captured in the schema.

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

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

Schema coverage is 75%, so most parameters are documented in the schema, establishing a baseline of 3. The description enumerates output categories (grids, slabs, piers) but adds no syntax or format detail beyond what the schema already provides for bays, story_heights, and section inputs.

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

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

States a specific verb ('Build') and resource ('a complete regular building'), then enumerates exactly what is created: grids, stories, materials, sections, frames, braces/shear walls, slabs, supports, diaphragm, load patterns, and combinations. This distinguishes it cleanly from the granular siblings like etabs_new_model, etabs_set_stories, etabs_add_frames, and etabs_define_combinations that it subsumes.

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?

Gives a clear forward workflow ('Follow with lateral loads (etabs_define_seismic_load ...), then analysis'), telling the agent what to call next. It does not explicitly state when to prefer this one-shot generator over the granular building tools, so the boundary against those siblings is left implicit.

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

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

Annotations already declare the safe read-only, idempotent, non-destructive profile, so the bar is lower. The description adds real context beyond that: the hard dependency on a prior run_design call and the unit convention ('Areas are in present units'), which an agent cannot get from annotations or schema.

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

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

Two dense sentences that front-load the resource and prerequisite before the output inventory; every clause (element types, result kinds, unit note) carries information and none is redundant padding.

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-format detail is not required, and annotations cover the safety profile; the description still supplies the prerequisite and unit convention. The only notable gap is pagination/limit behavior for a tool that can return up to 20000 rows, but overall it is complete enough to invoke correctly.

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

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

Schema coverage is only 50% (limit and element lack descriptions), so the description has some compensating duty. It implicitly maps the element enum values by listing beam, column and joint outputs, and clarifies units, but says nothing about limit, names, or envelope semantics, so it only partially covers the gap. Baseline 3 for this coverage level is appropriate.

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

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

States a specific verb and resource ('get concrete frame design results') and enumerates the payload: beam longitudinal/shear reinforcement, column PMM ratios and areas, joint shear, and capacity ratios. The 'concrete frame' qualifier cleanly separates it from the sibling wall/slab design getters, so an agent can select it without opening the schema.

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

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

Explicitly states the prerequisite that results are only available 'after etabs_run_design(kind='concrete')', which is the key usage condition. It does not, however, name alternatives such as etabs_get_design_summary or etabs_get_wall_design or state when-not to use it, so it falls short of full routing guidance.

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

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

Annotations already declare the full safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the burden is reduced. The description does add genuine behavioral context beyond annotations: results are ordered 'worst members first' and include the governing combo. It does not mention pagination or how 'worst' is defined, so it adds value but not richly.

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 compact sentence that front-loads the core purpose and orders the two output modes clearly, ending with the ordering behavior. No filler; the only slight shortfall is that key routing context is absent rather than the text being poorly 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?

An output schema exists, so return-value description is largely covered and the description need not explain the response shape. However, for a results tool sitting among get_results, get_concrete_design, get_wall_design, and design_report, the description omits which one to pick and whether design must have been run, leaving a meaningful 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 only 33%, with 'limit' undocumented in both places. The description partially compensates by clarifying the 'kind' branch (steel ratios vs. concrete reinforcement) and hinting at result content, but it says nothing about limit/truncation semantics. Baseline 3 fits: it lifts the enum meaning but leaves one parameter opaque.

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?

Names a specific verb and resource ('Design results per member') and enumerates exactly what is returned for each kind: steel D/C ratios with governing combo or concrete required reinforcement. It is a clear, self-contained statement of purpose, though it never distinguishes itself from nearby siblings like etabs_get_concrete_design, etabs_get_results, or etabs_design_report.

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

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

There is no explicit when-to-use guidance, no prerequisite stated (e.g., that a design must be run first via etabs_run_design), and no mention of alternative tools. The only implied usage is the steel/concrete branch, which is really a parameter choice rather than routing guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description adds scope (which tables) but says nothing about pagination defaults, filtering behavior via 'where,' or the effect of limit/offset, which is the remaining behavioral gap. With annotations carrying the load, a 3 is appropriate.

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

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

Two sentences, front-loaded with the core action and the escape hatch to the sibling tool. The long enumeration of result categories is justified but slightly dense; otherwise no waste.

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 values need no explanation, and the core selection question (which tool / which result) is answered. Gaps remain around pagination and load-case vs load-combination semantics for a 7-parameter tool, but the essential call guidance is present.

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

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

Schema description coverage is 43% and the description does not cover group, limit, offset, load_cases, or load_combinations behavior. It does help frame the 'result' parameter by enumerating the result categories, and the 'where' filter has its own schema example, so there is marginal added value, but the low coverage is not compensated.

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

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

States a specific verb ('Read analysis results') and enumerates the concrete result categories it covers (base reactions, story drifts, joint displacements/reactions, modal periods, element forces, piers/spandrels). It also names the differentiating sibling (etabs_get_table) so the agent can tell the two apart without opening either schema.

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

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

Explicitly routes the agent: use this for the listed result tables, and 'For any other result table use etabs_get_table.' The when-to-use and the alternative are both stated directly with a clear selecting condition.

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

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

Annotations already declare the safe read-only/idempotent profile, so the description's job is lighter. It adds a genuinely useful behavioral trait not in the annotations: results are returned 'worst first'. It does not describe how the limit/pagination interacts with that ordering.

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 that leads with the resource, then the prerequisite, then the returned content. No filler and nothing buried.

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 values need not be documented here. The prerequisite, the two result branches, and the ordering are all covered; only the limit parameter is thin, which is minor given the output schema.

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

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

Schema description coverage is 0%, so the description must carry the parameters. It implicitly maps the two result categories to part='strips' vs part='punching' (enum values are never quoted), but 'limit' is completely unexplained. Partial compensation only.

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

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

States a specific verb+resource (concrete slab design results) and enumerates the two result categories it returns: design-strip flexure/shear reinforcement and punching shear checks at columns. This clearly separates it from etabs_get_wall_design and etabs_get_concrete_design, though it never names those siblings 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?

Gives an explicit prerequisite: results are available 'after etabs_run_design(kind="concrete_slab")', which tells the agent when the tool is valid. It does not, however, state when to prefer this over etabs_get_concrete_design or etabs_get_design_summary, so the routing guidance is incomplete.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and non-openWorld, so the safety profile is covered. The description adds one genuinely useful behavioral detail beyond that – the ordering ('top story first') – but says nothing about auth/connection requirements or freshness of the 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?

A single compact fragment with zero filler, and the key ordering detail is front-loaded. It is efficient, though the fragmentary phrasing reads more like a schema note than a sentence.

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 trivial (no inputs) and an output schema exists, so the definition needn't document return values. The description supplies the one piece of information the structured fields lack – result ordering – for a simple, adequately covered definition.

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

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

The tool takes no parameters, so there is nothing for the description to disambiguate; the baseline for a zero-parameter tool applies. The listed fields (name, elevation, height, master/similar settings) describe output, not inputs, so they add no 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?

States the resource (story table) and its content precisely, and the 'get' name plus 'table' framing make clear it is a read of existing stories, implicitly distinguishing it from the setter sibling etabs_set_stories. It does not explicitly name an alternative, so it stops short of a 5.

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

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

There is no guidance on when to call this versus related introspection tools such as etabs_model_overview, etabs_list_objects, or etabs_list_tables, nor any stated preconditions (e.g. a model must be open/connected). Usage must be inferred entirely from the name.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuine value with the unit-handling rule ('Values with units are in present units'), but says nothing about row limits, pagination, or the cost of large table reads.

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

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

Two short, front-loaded sentences with no filler and the core purpose stated first. It is arguably too terse for a 9-parameter tool, but every sentence 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?

With an output schema present, return values need no explanation, and annotations cover safety. However, for a 9-parameter table reader with a 20,000-row cap and pagination params, the description omits practical caveats (large reads, filtering strategy) that an agent would benefit from.

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 67%, so most parameters (table_key, where, fields, numeric, load_cases, group) are documented in the schema itself. The description adds only the units note, which loosely relates to the 'numeric' flag but does not explain it or the limit/offset behavior.

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

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

States a specific verb and resource: 'Read any ETABS database table as rows', which clearly separates it from list/edit siblings like etabs_list_tables and etabs_edit_table. It does not explicitly name the sibling that produces the required table_key, so it stops short of full differentiation.

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

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

The description gives no when-to-use or when-not-to-use guidance and names no alternative. The UI anchor '(Display > Show Tables)' hints at context but does not tell an agent when to prefer this over etabs_list_tables, etabs_get_results, or etabs_list_objects.

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

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

Annotations already declare readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds real behavioral value beyond them: results are ordered 'worst first' and the pier payload includes messages and boundary zones while spandrels include flexural and shear reinforcement.

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

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

Two short sentences, no filler. The resource and its contents lead, and the prerequisite is a tight trailing clause.

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 detail is not required, and the prerequisite plus result-family split covers the core use. The gap is the unexplained filter parameters (label, story, limit), which leaves an agent guessing at how to narrow a result 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?

Schema description coverage is 0% for four parameters. The description explains the 'kind' enum by contrast (piers vs spandrels) but says nothing about 'label', 'story', or 'limit', so most of the filtering surface must be inferred from bare parameter names.

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

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

States a specific verb (get) and resource (shear wall design results) and enumerates the two result families with their payloads. 'Wall design' cleanly separates it from siblings like etabs_get_slab_design, etabs_get_concrete_design, and etabs_get_design_summary without needing to 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?

Gives an explicit prerequisite: 'Run etabs_run_shear_wall_design first,' which tells the agent when this tool is callable and prevents an empty-result call. It does not, however, state when to prefer this over the other design-result siblings or what happens if the design has not been run.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false, and non-idempotent behavior, but the description adds the crucial global-state disclosure that switching changes 'which one every other tool acts on' — a side effect no annotation conveys. It stops short of describing what happens to the previously active instance or the confirm/close_etabs semantics (those live in the schema).

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

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

Two sentences, zero waste. The operational scope is front-loaded in sentence one and the motivating use case follows in sentence two.

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

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

With an output schema present, return values need no explanation, and the description covers all three action modes plus their motivation. The only gap is the safety sequence around 'remove' (confirm plus close_etabs), which is split off into the schema rather than surfaced in prose.

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

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

Schema coverage is 50%: name and close_etabs carry descriptions, while action and confirm do not. The description supplies the intent behind 'use' (retargeting every other tool), but adds no syntax or constraint detail for confirm or for removal of the active instance, so it only marginally compensates.

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 first sentence states three specific verbs (list / switch / remove) over a named resource (the ETABS instances this server drives) and ties them to the action enum. It also implicitly separates itself from neighbors like etabs_list_installations and etabs_connect by scoping to instances this server manages.

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 'Typical use' sentence gives concrete scenarios (side-by-side comparison, copying data between models), which implies when the tool is relevant. However, it never says when NOT to use it, nor does it route the agent to alternatives such as etabs_connect, etabs_disconnect, or etabs_list_installations.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the extra credit goes to non-obvious behavior: non-blocking execution ('Never blocks'), the state machine (running/done/failed), elapsed time, and the log tail only while running. The return details are somewhat redundant with the output schema, keeping this from a 5.

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 dense sentence that front-loads the core purpose (job status) and then lists the supporting details. Every clause earns its place with 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?

With an output schema present, return values needn't be restated, yet the description nonetheless sketches the result shape and the non-blocking contract, making it self-sufficient for calling the tool. The only gap is the lack of explicit routing against etabs_job_wait and etabs_analysis_status.

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

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

Schema description coverage is 100% and the single job_id parameter is documented there, including 'omit for the most recent job.' The description adds nothing about job_id, so the baseline 3 for schema-carried semantics is appropriate.

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

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

States a specific verb and resource ('Status of a background job') and enumerates the job types and states it reports. The closing 'Never blocks' implicitly distinguishes it from the blocking sibling etabs_job_wait, so an agent can tell the two apart.

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

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

Usage is only implied: the agent can infer this is a non-blocking poll of a job it started, and 'Never blocks' hints at a contrast with etabs_job_wait. However, it never names the alternative or states explicitly when to poll versus wait, so the routing guidance is left to inference.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds the behavior the annotations cannot express: this call can return before the job completes and must be re-issued, and the wait is bounded by timeout_seconds.

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

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

Two short sentences, no filler, with the core action and the retry instruction front-loaded. Every clause carries information an agent needs.

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

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

With an output schema present, the description correctly does not enumerate return values and instead points at etabs_job_status for the shape, which is enough for a zero-required-parameter tool. The only small gap is not stating when to prefer this over polling etabs_job_status.

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

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

Schema description coverage is 100%, and the schema already explains job_id defaulting to the most recent job and timeout_seconds semantics including the max of 3600. The description's mention of timeout_seconds adds no detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (wait) and resource (background job), plus the blocking scope ('up to timeout_seconds'). It also anchors itself to a known sibling by noting the result has the same shape as etabs_job_status, so an agent can place it precisely among the job tools.

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

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

'Call again if it is still running' gives explicit follow-up guidance for the timeout case, which is the main usage decision here. It implies but never explicitly contrasts with etabs_job_status (poll now vs. block), which is the one alternative an agent might weigh, so it stops short of a full when/when-not statement.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description contributes one behavioral detail beyond structured data: results are returned newest first, which affects how the agent consumes the list. It does not mention pagination or list size.

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 short sentence with the resource and its ordering front-loaded. Nothing is wasted and nothing extraneous is added.

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 values need not be described, and there are no parameters or annotations gaps to compensate for. The only omission is any hint of list size or pagination, which keeps it just short of 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 tool takes zero parameters, so the baseline is 4. There is no parameter syntax for the description to clarify, and the schema is trivially complete.

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

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

States a specific verb (list) and resource (checkpoints) scoped to the open model, and adds the ordering. It implicitly distinguishes itself from etabs_checkpoint and etabs_restore_checkpoint by being the read/list variant, though it does not 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 when-to-use guidance, no prerequisites, and no named alternatives. The agent must infer from the name alone that this is the read counterpart to etabs_checkpoint and etabs_restore_checkpoint.

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 annotations already declare readOnlyHint, idempotentHint, openWorldHint=false and destructiveHint=false, so safety is covered structurally. The description adds the local-machine scope and the v22+ support constraint, which is real context, but says nothing about how this relates to etabs_instances or what discovery enables downstream.

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

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

One compact sentence with the primary resource front-loaded and no filler. The two-headed scope (installations and running instances) is slightly denser than ideal but still 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?

An output schema exists, so return values need not be described. The remaining gap is routing: with etabs_instances and etabs_status among the siblings, an agent cannot tell from this description alone which discovery tool to call, and the description does not close that 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?

Zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies. The description correctly implies no inputs are needed.

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

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

Specific verb (List) plus two concrete resources (ETABS installations on this machine, and currently running ETABS instances), with a version-support qualifier. It does not, however, distinguish itself from the sibling etabs_instances, which appears to cover overlapping ground.

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 when-to-use guidance is given: nothing says this is a discovery/pre-flight step before etabs_connect, and no alternative is named for the 'running instances' half even though etabs_instances exists as an obvious sibling. Usage can only be inferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds only what data is returned (e.g., self-weight multiplier, scale factors), which is output-schema territory. It does not disclose any additional behavioral traits like authentication requirements or rate limits.

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

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

The description is a single, tightly packed sentence that front-loads the main resource (load patterns) and lists the other returned categories. Every phrase adds specific detail without redundancy or 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 has no parameters, rich annotations, and an output schema, the description is nearly complete. It adequately conveys what categories of load definitions are returned. A minor gap is the lack of any context about whether it operates on the currently connected model, but this is not critical for a read-only list operation.

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 takes zero parameters, so there is no parameter semantics to document. Per the scoring rule, a zero-parameter tool receives a baseline of 4. The description cannot add meaning beyond an empty schema.

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

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

The description enumerates the components of load definitions (patterns, cases, combinations) but never states an explicit verb such as 'list' or 'retrieve'. It relies on the tool name to convey the listing action. The resource is clear, but the purpose is only implied rather than stated directly.

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_define_load_patterns or etabs_define_combinations. No prerequisites, conditions, or exclusions are mentioned. The agent must infer its usage entirely from the name and 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?

Annotations already declare readOnly, idempotent and non-destructive, so safety is covered. The description adds that geometry is reported in present units and clarifies that 'name' is the identifier every API call expects while 'label' is GUI display text — genuinely useful behavior context. It says nothing about pagination or truncation behavior, which matters for a list operation with a default limit of 200.

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

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

Two short sentences with no filler, and the core listing behavior is front-loaded ahead of the identifier-clarification note. Efficient and easy to scan.

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 explanation is unnecessary. However, for a list tool with a default limit of 200 and a 5000 maximum, the absence of any note about result truncation or paging leaves a real gap 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?

Schema coverage is only 40%: 'kind', 'limit' and 'offset' have no descriptions. The description partially compensates by enumerating the object kinds ('frames, areas or points') that map to the kind enum, but it adds nothing about limit/offset paging semantics. Roughly a baseline-plus score given the coverage 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?

States a specific verb (List) and the resource (frames, areas, points) plus what is returned (geometry in present units, sections, stories). The addition of the name/label distinction sharpens what the tool is for. It does not, however, distinguish itself from nearby siblings such as etabs_find_objects or etabs_model_overview.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tool is named. The name/label note implies the tool is the way to obtain API identifiers, but the agent must infer that itself.

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

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

Annotations already declare read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful scope detail (types, shape and dimensions in present units, area property categories), but does not go beyond that to explain behavior such as model-connection requirements or result completeness.

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