DrapeCut

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

Beyond the annotations, it discloses key behavioral details: ranking order by coverage, percentage above lock, and maximum shear; that this is a stated comparison rule rather than a global optimum; that runs use requested or preset pitch without hidden coarse approximation; and that backend result IDs are temporary and should be exported promptly.

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

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

The description is front-loaded with the core action and then adds only operationally relevant details: seed handling, ranking rules, pitch behavior, and export urgency. Every sentence 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?

The output schema exists, so return values need not be described, and annotations cover basic safety flags. However, for a complex 9-parameter tool with zero schema description coverage, the description leaves too many parameter meanings and usage boundaries unstated to be fully complete.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It partially explains seed, angles, and pitch, but leaves offset, hole_area, lock_angle, fabric_id, workspace_id, and mesh_id without added semantic detail, which is insufficient for a 9-parameter tool.

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: 'Compare up to 12 warp angles, sequentially, at one fixed seed and cloth configuration.' This clearly distinguishes it from a single-run sibling like run_drape by emphasizing batched sequential comparison under fixed conditions.

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 by stating the comparison scope and seed-omission behavior, but it does not explicitly say when to choose this tool over alternatives such as run_drape or suggest_seed. The context is clear enough to infer intent, but no exclusions or sibling routing are provided.

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

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

Annotations already declare this is a non-idempotent, non-destructive write, so the safety profile is covered. The description adds real behavioral context beyond that: it returns a job_id requiring polling, seeds are laid first and remaining ground is filled up to max_pieces, and overlap is measured in mm. It does not say what prior layout state, if any, is replaced.

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?

Roughly four short sentences, front-loaded with the core action and scoping clarification, then the workflow steps. The hard-wrapped formatting is slightly awkward but no sentence 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, return values need not be described, and the polling/export guidance is useful. However, for an 11-parameter geometry-creation tool with zero schema documentation, the description omits the meaning of most parameters, leaving the agent guessing on the majority of inputs.

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

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

Schema description coverage is 0% across 11 parameters, so the description must carry the burden and mostly fails to. It clarifies overlap (mm), seeds (laid first) and indirectly max_pieces, but leaves angle, pitch, offset, hole_area, lock_angle, fabric_id and the two required IDs 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?

States a specific action and object: 'Start covering one surface with multiple pieces of the same ply/fabric,' and explicitly negates the nearest conceptual neighbor ('This is not a laminate stack'). It does not, however, differentiate itself from other sibling operations like run_drape or suggest_seed, so the agent must infer the boundary.

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 usage context (cover one surface with repeated ply pieces, not a laminate stack) and a follow-up workflow: poll with get_job(kind='layout'), export with layout=true. It stops short of naming when to prefer alternatives such as run_drape or suggest_seed first.

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 openWorldHint=false and destructiveHint=false, so the description must carry the rest — and it does, disclosing the two-hour lifetime and that the ID/links are access-granting secrets that must not be published. It omits what happens after expiry and whether a workspace can be reclaimed, leaving a small gap.

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

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

Three short sentences: purpose and return values first, ordering guidance second, a security caveat third. 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 no elaboration; the description still names them for orientation. For a zero-parameter creation tool with an expiry and secret-handling nuance, the description covers everything 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?

The tool takes zero parameters, so per the baseline there is no parameter semantics to explain 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 and resource ('Create a private two-hour workspace') and names the outputs ('its ID and CAD upload page'). It also positions itself against siblings by telling the agent to call it before load_sample or import_part, so an agent can distinguish it from create_layout and the rest without opening a 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?

'Start here before loading a sample or importing a user's CAD part' gives explicit sequencing relative to named sibling tools. It stops short of stating when NOT to use it (e.g., reusing an existing workspace ID), which keeps it from 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 mark this non-read-only, non-idempotent, non-destructive, but they say nothing about output lifecycle. The description adds real value beyond them: the return is a temporary download_url and it must be downloaded 'before workspace expiry', which tells the agent the artifact is ephemeral.

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 front-loaded sentences with little waste: capability, mode hint, and expiry warning in that order. The only detraction is the stray layout_id reference, which spends words on a parameter that isn't real.

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 structure needn't be explained, and the expiry note is a nice touch. However, for a 6-parameter tool with zero schema descriptions, omitting grid/paper semantics and citing a nonexistent layout_id leaves real gaps 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 description coverage is 0% across 6 parameters, so the description carries the full burden and largely fails it: it explains only format (DXF/PDF) and layout, omits grid, paper, workspace_id, and result_id entirely, and mentions a nonexistent layout_id. One of six parameters is genuinely clarified.

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 ('Export a result as DXF or tiled 1:1 PDF') and even names the deliverable ('temporary download_url'). It doesn't explicitly differentiate from siblings, but no sibling tool competes as an exporter, so the purpose is unambiguous.

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

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

Gives one conditional mode hint ('Use layout=true with a layout_id to export all pieces'), which is useful, but that same sentence references a 'layout_id' parameter that does not exist in the schema, weakening the guidance. No when-not-to-use or alternative paths are offered.

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 behavioral context beyond that: the polling-loop pattern, the 'done=false' completion signal, and what each return path contains. It does not discuss failure/timeout behavior, which would push it higher.

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 core action and polling instruction, then the return-path distinctions. Every clause carries information; 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?

An output schema exists, so return-field enumeration is not strictly required, yet the description usefully summarizes the shape of each completion branch. Combined with the polling guidance and sibling routing, an agent has enough to invoke and follow up correctly; missing only edge-case behavior on incomplete jobs.

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 three required parameters, so the description must compensate — it partially does by implying 'kind' semantics through the STEP/layout branches, but says nothing about workspace_id or job_id (format/constraints live only in the schema patterns). This is roughly baseline for a schema-documented-elsewhere tool with a real gap.

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

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

The description states the specific action (poll a job) and names the two resource types (STEP import, multi-piece layout), which map directly to the 'step'/'layout' enum values in the schema. An agent can immediately tell this is a status-check tool, distinct from export_pattern or create_layout 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?

It gives explicit polling guidance ('retry after a short delay while done=false') and routes the agent to the correct alternative for the common follow-up need ('use list_faces for geometric descriptions and pagination'). It also tells the agent what each completion path enables (step_id, layout_id for export_pattern).

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 a non-readonly, non-destructive, non-idempotent, closed-world mutation, so the safety profile is already covered. The description adds genuinely new behavioral context: the call returns an async job that must be polled, and STEP/STP requires a follow-up face-selection step. It omits permission/auth requirements and what happens on duplicate imports, but adds real value beyond 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?

Three short sentences, front-loaded with the core action and then the prerequisite and follow-up flow. 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?

An output schema exists so return values needn't be restated, and annotations cover the safety profile. The description completes the picture with the job-polling workflow and face-selection step. Only minor gaps remain (workspace_id meaning, auth, duplicate handling) for a 2-parameter mutation.

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 both parameters rely on the description. It usefully explains where upload_id comes from (list_uploads) and ties it to the import target, but says nothing about workspace_id or the expected ID formats. Partial compensation for the coverage gap warrants a 3.

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

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

States a specific verb and resource ('Import a file already uploaded to this workspace') and constrains scope to already-uploaded files, which cleanly separates it from load_sample or list_uploads. It also names the supported format (STEP/STP), so an agent knows what it produces a part/job from. It stops short of explicitly differentiating itself from every sibling, but the scope qualifier does most of that work.

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 chain: obtain upload_id from list_uploads, and for STEP/STP poll the returned job with get_job(kind='step') before inspecting and selecting faces. That is concrete when-to-use and next-step guidance. It does not state exclusions (e.g., what to do for non-STEP formats or when not to import), so it falls short of a full routing rule set.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered by structured data. The description's enumeration of returned fields is content that largely overlaps the output schema, and it adds no new behavioral context such as whether this is a fixed catalog, ordering, or filtering behavior.

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

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

A single front-loaded sentence with no filler. It is slightly padded by listing return fields that the output schema already documents, but no sentence 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 0 parameters, rich annotations, and an output schema present, the description does not need to explain return values or permissions. It adequately covers what the tool returns, leaving only minor gaps around selection guidance.

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

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

The tool takes zero parameters, so the baseline is 4. Nothing in the description is needed to clarify parameter usage, and none is missing.

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 pairs a specific verb ('List') with a specific resource ('fabric IDs') and enumerates the attributes returned (locking angles, tow pitch, thickness, UD settings). That is enough to distinguish it from sibling list_* tools by resource, but it offers no explicit contrast with any sibling or usage framing.

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

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

There is no statement of when to call this versus alternatives (e.g., list_samples, load_sample) and no prerequisites or exclusions. The only guidance is implied by the resource name itself, which is minimal.

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, so the safety profile is covered. The description adds a backend dependency ('requires the MCP face-metadata endpoint in the configured backend') and an interpretation caveat about tessellation vs. intended draping surface, which is meaningful behavior beyond the structured fields.

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, front-loaded sentences with no filler; the primary capability leads and the caveats follow. Slightly verbose line-wrapping but every sentence adds 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 not be explained, and the annotations cover safety. However, the four parameters are invisible in both description and schema, so an agent cannot tell how to page or what the required IDs must look like — a real gap for a list tool with pagination.

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 all four parameters, so the description carries the full burden and explains none of them. It says nothing about workspace_id/step_id formats or the limit/offset pagination controls (defaults 50, max 100), leaving required inputs and paging behavior 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?

States a specific verb (Inspect) and resource (STEP face IDs) and enumerates the returned attributes (areas, bounds, centroids, neighbours, mesh normals). It is clearly a read/inspect tool distinct from siblings like select_faces or mesh_landmarks, though it never names those siblings to sharpen the boundary.

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 real context: it requires the MCP face-metadata endpoint, warns that centroids/bounds describe the tessellation rather than a guaranteed intended surface, and tells the agent to ask for explicit face IDs when the surface cannot be identified here. That implies the select_faces handoff without naming it as an alternative, so it stops short of explicit when-not 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 readOnly, idempotent, non-destructive and closed-world, so safety is fully covered. The description adds only mild context (built-in, no upload required) and says nothing about return shape or ordering, which the output schema presumably handles.

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 distinguishing qualifier ('without uploading a file') is placed 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?

For a zero-param, fully annotated read tool with an output schema, the description is nearly complete; the only missing element is an explicit pointer to the companion load tool for the next step.

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 the baseline is 4; the schema coverage is 100% and there is nothing for the description to compensate for.

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 (built-in example parts) and implicitly separates itself from siblings like list_uploads by noting these need no file upload. An agent can identify what it returns 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?

The phrase 'can be loaded without uploading a file' implies the tool is used to discover loadable samples (paired with a load_sample-style sibling), but it never names that companion tool or states when to prefer this over list_uploads or list_fabrics. Usage is only implied.

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 a closed world, so safety is covered. The description adds only the fact that results are scoped to files uploaded via this workspace's upload_url. It says nothing about pagination, result volume, or ordering, but an output schema exists so return shape is less of a gap.

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

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

A single compact sentence with the core action front-loaded and the follow-on routing tip attached. No filler, though the semicolon-joined second clause about upload_id/import_part reads as a slightly disjointed add-on.

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-parameter read-only listing tool with an output schema and full annotation coverage, this covers purpose and next-step routing adequately. The only real gap is workspace_id provenance, which the schema does not supply either.

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

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

Schema description coverage is 0% and the single parameter workspace_id carries only a 48-hex pattern constraint with no prose. The description implies workspace scoping ('this workspace's upload_url') but never explains what workspace_id is or where to obtain it. With one required param and no schema docs, the description does only partial work.

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: list files uploaded through this workspace's upload_url. The follow-on mention of import_part helps place it in the workflow, though 'upload_url' is somewhat jargon-dependent and the sibling list contains similarly named list_* tools (list_fabrics, list_faces, list_samples) that are not differentiated.

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 a clear workflow: use this to discover uploads, then pass an upload_id to import_part. That gives real context for when to reach for it. It stops short of explicit when-not guidance or naming which sibling to use for other listing 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 readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the agent knows this mutates state and is not reproducible. The description adds only that it targets a 'built-in' sample and yields a mesh_id; it does not explain what registration creates, whether re-registering duplicates state, or any permission 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 action, that carries no filler. The return value note is appended efficiently rather than 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 the mesh_id return detail is somewhat redundant but harmless. For a non-idempotent mutation with two undocumented, strictly-patterned parameters, the description omits prerequisite and repeat-call 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 0% for two required parameters (name, workspace_id), both with strict regex patterns that the description never mentions. The word 'sample' loosely hints at the name argument, but the description adds no format, constraint, or meaning for either parameter, leaving the agent without guidance where the schema is silent.

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: 'Register a built-in sample'. It also discloses the return artifact ('return a mesh_id'), which cleanly separates it from the read-only sibling list_samples. It stops short of naming any sibling explicitly, so it does not reach 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?

'for draping' implies the downstream use case, giving the agent a rough sense of when this tool matters. However, there is no statement of prerequisites, no exclusion of alternatives, and no guidance on when to prefer this over list_samples or import_part.

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, not open world). The description adds useful behavioral detail beyond that: pagination is per category, capped at 100, full section polylines are omitted, and next_offset drives subsequent pages.

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

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

The description is front-loaded with the core action and then adds only essential details: units, pagination behavior, returned content, and omitted content. Every sentence earns its place with no redundant framing.

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 read-only annotations, an output schema, and patterned ID parameters, the description provides enough detail to invoke and page the tool. It still lacks guidance on how this inspection relates to sibling tools like suggest_seed, which would complete the picture.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It partially explains pagination parameters via 'max 100 per category' and 'next_offset', but gives no semantics for the required workspace_id and mesh_id parameters, leaving half the parameters 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?

States a specific verb and resource: inspect seed landmarks, with units (mm) and pagination scope. It does not, however, distinguish itself from sibling tools such as suggest_seed or list_faces, leaving the agent to infer the boundary.

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

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

The description gives a pagination instruction ('Follow next_offset for more points') but does not say when to use this tool versus alternatives like suggest_seed or list_faces. No prerequisites, exclusions, or workflow context are provided.

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

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

Annotations already declare readOnly=false, destructive=false, idempotent=false, and openWorld=false. The description adds useful behavioral context beyond those hints: omitted seed is suggested, omitted pitch/lock_angle use the fabric preset including UD spread/compression, the API may increase pitch, and pitch_used reports the actual resolution. It still does not explain persistence/export mechanics or auth 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?

The description is front-loaded with purpose and return values, then efficiently adds parameter caveats and one important domain warning. Every sentence carries useful meaning, though the dense run of parameter details could be easier 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 values need not be explained, and annotations cover the safety/idempotency profile. With 0% schema coverage across 9 parameters, however, the description leaves required IDs and fabric_id semantically unexplained and only names the result_id export mechanic.

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 parameter meaning. It provides units for pitch/offset (mm), hole_area (mm², null bridges holes), angle in degrees, and lock_angle preset behavior, but it never explains the required workspace_id or mesh_id parameters, fabric_id is only shown by its default, and seed semantics remain vague.

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 ('Drape') and resource ('one fabric at one warp angle') plus what is returned: statistics and an exportable result_id. However, it does not explicitly distinguish this tool from siblings such as compare_drapes or suggest_seed, leaving some sibling routing 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 description does not state when to use this tool versus alternatives, nor does it name any when-not conditions. Parameter default behavior is explained, but that is not usage guidance; an agent must infer that this is for a single drape 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 already disclose readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the safety profile is covered. The description adds that the tool reports connectedness, which is genuinely useful behavioral context about the result, but it never states whether the created mesh persists, what happens on invalid or non-adjacent face sets, or any side effects on the workspace.

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 with the action front-loaded and the input constraint appended. No filler, though the semicolon clause could be dropped without loss if it were moved elsewhere.

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, but for a non-idempotent creation tool with three fully undocumented required parameters and 0% schema coverage, the description leaves too much unexplained — no workspace_id semantics, no failure modes, no relation to run_drape.

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 three required parameters. The description clarifies that face_ids are STEP face IDs and must be explicitly chosen, but says nothing about workspace_id, step_id, whether all three belong to the same workspace, or ID validation.

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 and resource ('Create a drapable mesh') and scopes the input to 'explicitly chosen STEP face IDs', which distinguishes it from list_faces and run_drape. It stops short of explicitly naming sibling alternatives, but the action is unambiguous.

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

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

There is no when-to-use guidance, no exclusions, and no mention of the workflow siblings (list_faces to obtain face IDs, run_drape to consume the mesh). The word 'explicitly chosen' faintly implies the caller must already hold valid IDs, but nothing directs the agent to 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 declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds useful context by naming the hosted solver and connection/workspace limits, but does not otherwise describe behavioral traits such as latency, auth requirements, or rate-limit behavior.

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

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

The description is a single front-loaded sentence with no filler. Every clause contributes to the tool's purpose.

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

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

Given the low complexity, zero parameters, available output schema, and rich read-only annotations, the description is complete enough to select and invoke the tool. Return values are covered by the output schema, so the description need not explain them.

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 are no parameter semantics for the description to clarify. The baseline for zero-parameter tools is 4.

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: 'Check the hosted DrapeCut solver' and 'read connection/workspace limits.' This clearly distinguishes it from sibling tools like run_drape, get_job, and create_workspace, which all operate on drapes or workspaces rather than server health.

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

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

The description gives no explicit when-to-use, when-not-to-use, or alternative guidance. An agent must infer that this is a health or capacity check, with no indication of when to call it relative to other tools.

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

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

Annotations already disclose that the tool is not read-only, not idempotent, and not destructive. The description adds that it validates coverage with an actual drape, which is useful behavioral context beyond the annotations. It still does not explain side effects, persistence, cost, or what a 'seed' is, leaving meaningful gaps for a non-read-only 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?

Two short sentences with no wasted words. The core action is front-loaded, and the secondary validation note is appropriately subordinate.

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. However, with four parameters at 0% schema description coverage and no usage guidance, the description is too sparse for an agent to reliably invoke the tool. Annotations help with the safety profile, but key operational details 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 0%, and the description provides no explanation of workspace_id, mesh_id, angle, or lock_angle. With four undocumented parameters, the description fails to compensate for the complete lack of parameter semantics in 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 and resource: suggesting a starting point (seed) on a mesh. It adds a validation step with an actual drape, giving clear domain purpose. However, it does not explicitly differentiate itself from sibling tools like run_drape or compare_drapes.

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

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

No explicit guidance on when to call this tool versus alternatives such as run_drape or compare_drapes. The phrase 'Validate its coverage with an actual drape' hints at a workflow but does not state prerequisites, sequencing, or when-not-to-use conditions.

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