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

No annotations are provided, so the description carries the full burden. It does disclose meaningful behavior — backups, an undo transaction, save/reopen, requested-value checks — which tells the agent this is a transactional, recoverable mutation. However, it omits permissions/auth requirements, the effect on unlisted settings, and the return/response shape, leaving notable gaps for a write tool with zero annotation coverage.

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?

It is short and front-loads the core purpose, which is good. But it is terse to the point of being cryptic, with jargon like 'requested-value checks' and 'Coordinates mm' that a reader must decode.

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 no annotations, no output schema, and 0% parameter coverage, the definition should explain the operations payload format and what gets changed/returned. It leaves the most important element — the structure of 'operations' — entirely unexplained.

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

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

Schema description coverage is 0% and the description does not explain 'project', 'new', or the opaque 'operations' array (an array of free-form objects). 'Coordinates mm' hints at the unit convention for operation values but does not document the parameter structure, so the description fails to compensate for 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?

The opening clause 'Create/edit models only under configured write root' gives a clear verb (create/edit) and resource (models) plus a safety constraint. It implies a plan-application tool that mutates model data, which distinguishes it in spirit from siblings like bridge_validate_plan or bridge_preview_on_copy, though it never names 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?

There is no explicit when-to-use guidance or routing to alternatives. The phrase 'only under configured write root' signals a precondition but not when to choose this tool over bridge_validate_plan or bridge_preview_on_copy.

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

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

No annotations exist, so the description carries the full burden. 'Return' implies a read-only operation, and the clause stating research evidence is distinguished from actual local integration evidence does disclose something about the returned content's provenance. However, it says nothing about authentication, whether it queries the host environment, or how the two evidence classes are distinguished.

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?

It is a single short sentence, which is appropriately sized, and the verb 'Return' is front-loaded. But the semicolon clause is cryptic enough that roughly half the text does not clearly earn its place for an agent trying to decide whether to call it.

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-parameter introspection tool with no annotations and no output schema, the description must explain what is actually returned. It never defines 'release scope', does not say what capabilities are enumerated, and gives no output shape, leaving an agent unable to predict the result of calling it.

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

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

The schema accepts zero parameters, so there is no parameter semantics for the description to add — baseline 4 applies. The description's only parameter-adjacent information is that no scope filter is offered, which is implicit in the 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 says 'Return release scope', which gives a verb but an ambiguous resource — 'release scope' is not clearly defined and the name 'bridge_capabilities' suggests something broader (system capabilities) that the text never confirms. The second clause about research vs. local integration evidence hints at scope but does not make the tool's purpose identifiable against 21 bridge_* 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?

There is no statement of when to call this tool, what question it answers, or how it differs from relatives like bridge_status, bridge_project_info, or bridge_catalogs. With 21 sibling tools and no routing guidance, selection is left entirely to inference.

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

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

No annotations are provided, so the description carries the full burden. "Inspect existing" implies non-mutating behavior and hints that the output feeds ID selection downstream, which is useful context, but it says nothing about permissions, completeness of listing, filtering, pagination, or what happens if the project has no such catalogs.

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 key verb and resource list come first. It is arguably too terse for the amount of undocumented structure it must compensate for, but nothing in it 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 no annotations, no output schema, and 0% parameter documentation, the one-line description leaves significant gaps: what a "collection" is, what IDs/fields are returned, and how the catalogs relate to project scope. For a tool whose entire job is enumeration, this is under-specified.

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

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

Schema description coverage is 0% and the description mentions neither parameter. The required "project" and the optional nullable "collection" (default null) are left entirely unexplained — notably, the description names five resource categories that presumably map to "collection" values but never says so or lists accepted values.

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

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

The description gives a specific verb (inspect) and enumerates the resource types involved (styles/materials/scales/layouts/schedules), so an agent knows this is a read-only catalog-discovery tool. It does not differentiate itself from closely named siblings such as bridge_inspect or bridge_capabilities, which overlap conceptually.

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?

"before selecting actual IDs" gives an implied workflow position (call this first, then pick IDs for other tools), which is genuine usage guidance. However, no alternatives or exclusions are named, and an agent cannot tell from the text when bridge_inspect would be preferable.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose two useful traits — that the destination must be new/writable and that the copy opens in an isolated process — but says nothing about permissions, the fate of the source project, reversibility, or the return 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, front-loaded sentence with no wasted words. It is efficient, though the brevity is partly responsible for the coverage gaps 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?

For a mutation tool that creates and opens a new project, with no annotations, no output schema, and 0% schema coverage, one sentence is inadequate. It omits preconditions, side effects on the source, and what the caller receives back.

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 neither 'project' nor 'output' is described anywhere. The description alludes to a 'destination' (output) but gives no format, path semantics, or whether the destination must not already exist, leaving both parameters effectively 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 (Copy) and resource (saved native project) plus the key qualifier that the destination is NEW and writable and that the copy is opened in an isolated process. It is clearly distinguishable from nearby siblings like bridge_save_as, though it doesn't explicitly name 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?

There is no when-to-use or when-not-to-use guidance, and no mention of alternatives such as bridge_save_as or bridge_preview_on_copy despite their presence in the sibling set. The copy intent is implied but nothing routes the agent between options.

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

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

With no annotations, the description carries full behavioral burden. It discloses content fidelity (actual drawings, no fake dimensions/tags) and optional embedded content, but says nothing about permissions, prerequisites (e.g., project must exist), side effects, reversibility, or failure modes for a creation operation.

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

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

A single dense sentence that front-loads the core action ('Create actual drawings') and appends content/constraint details. No filler, though the clause after the semicolon is slightly terse.

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

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

For a creation tool with no annotations, no output schema, and 0% schema description coverage, the description leaves critical gaps: parameter semantics, prerequisites, return value, and failure behavior. It provides only content hints, not 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 description coverage is 0% for two required parameters, and the description never explains what 'project' expects or what shape/fields 'drawings' array items require. It hints that drawings can contain level views and schedules, but this is not tied to the parameter structure.

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 ('Create actual drawings') and enumerates what the created drawings contain (embedded level views, optional native schedules/text titles). It implicitly differentiates from preview/inspect siblings via 'actual drawings' and the exclusion of 'fake dimensions or tags', though it doesn't name an alternative tool.

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

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

Gives no when-to-use or when-not-to-use guidance relative to siblings like bridge_render_view, bridge_inspect_drawings, or bridge_preview_on_copy. The constraint 'no fake dimensions or tags' is a content rule, not a routing rule.

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

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

With no annotations, the description must carry the full burden. It discloses useful behavior beyond the name: it imports via official IFC, verifies saved identities/heights, exports fresh grid coordinates, and removes its own carriers. However, it omits permissions, failure behavior, and what 'carriers' means, and the jargon is opaque.

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 create action and containing no filler. But the second sentence is dense with unexplained jargon ('identities/heights', 'own carriers') that reduces usability rather than being efficiently concise.

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

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

For a creation/mutation tool with no annotations, no output schema, and 0% schema description coverage across three parameters, the description leaves too much unspecified – parameter shapes, prerequisites, and error/side-effect semantics. It is not complete enough to invoke confidently.

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

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

Schema coverage is 0% with three parameters (project, levels, grid), yet the description only alludes to elevation_mm inside levels and the optional orthogonal grid. The 'project' parameter and the structure/shape of the nested levels and grid objects are undocumented in both schema and description, leaving the agent to guess.

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 clear verb ('Create') and resource ('a NEW native .rnp with levels at explicit elevation_mm and optional orthogonal Axis grid'), which is concrete enough to distinguish it from copy/save/inspect siblings. It does not explicitly name an alternative sibling, 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?

The trailing 'Does not modify existing level elevations' implies a when-not boundary (use something else to edit existing levels), but no alternative tool is named and no explicit when-to-use trigger is given. 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?

With no annotations, the description carries the full behavioral burden. It hints that output is 'protected' but does not say whether the path is overwritten, whether it must not already exist, what permissions are needed, or what happens on failure. Mutation/export side effects are essentially undisclosed.

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

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

A single front-loaded sentence with no filler, which is the right shape. It is terse rather than padded, though the terseness is part of why other dimensions fall short.

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 2-parameter export operation with no annotations, no output schema, and 0% parameter documentation, the description leaves too many gaps: return value, overwrite behavior, and both parameter meanings are unspecified. A caller could not reliably invoke this without trial and error.

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 both parameters, so the description must compensate and largely does not: 'output' is only loosely glossed as a 'protected output path' with no format or directory semantics, and 'project' is never explained at all (identifier? path? 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?

Names a specific verb (export) and resource (IFC4) and identifies the underlying mechanism (Renga API), so the agent knows this produces an IFC file rather than the PDF output of the sibling bridge_export_pdf. It stops short of describing how the result differs from other bridge_* operations, but 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?

There is no statement of when to choose this export over bridge_export_pdf, bridge_render_view, or bridge_save_as, and no prerequisites or preconditions (e.g. whether a project must be open first). Usage must be inferred entirely from the tool name.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that the output path must be new and must sit inside the write root, implying a write operation with an overwrite guard. It says nothing about permissions, error behavior on existing paths, or what happens to the target file, so it is only partially transparent.

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

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

A single sentence with the action front-loaded and the precondition appended. No filler, no repetition of the tool name, and every clause carries information.

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

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

For a write tool with no annotations, no output schema, and three undocumented parameters, the definition is too thin. An agent cannot tell whether omitting drawing_uuids exports everything, what 'project' expects, or what a failed write returns.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies the 'output' parameter (new path, inside write root) and gestures at 'drawings' via drawing_uuids, but says nothing about the required 'project' parameter or what a null drawing_uuids means (all drawings vs none), leaving two of three parameters semantically 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 verb and resource ('Export native drawings to one PDF') and implicitly separates itself from bridge_export_ifc and bridge_render_view by naming the PDF target. It never explicitly names an alternative, so it falls short of the 5 benchmark for sibling differentiation.

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

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

The constraint 'requires a NEW output path inside write root' gives a precondition for successful use, which is more than most. However, there is no guidance on when to choose this over bridge_export_ifc or bridge_render_view, and no statement of what happens if the path is not new.

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

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

With no annotations provided, the description carries the full burden. It usefully discloses the key behavioral trait - that this is a pure calculation with no model mutation - but says nothing about permissions, determinism, or how the computed offsets are returned.

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, output, units, and safety constraint are all packed in without 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?

For a 5-parameter geometry tool with no annotations, no output schema, and zero schema descriptions, this is too thin. The agent cannot tell what length/width/count represent geometrically or what the calculation returns.

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 5 parameters, so the description must compensate and largely does not. It hints at units (millimeters) and that piers are involved, but never explains length, width, count, or the end_pier/min_pier defaults.

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

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

States a specific verb+resource: 'Calculate explicit window offsets and piers in millimeters'. The phrase 'without mutating a model' implicitly separates it from the apply/mutate siblings, but no sibling is named, so differentiation is inferential rather than explicit.

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 alternative. The agent must infer that this is a pre-planning calculation step from the non-mutating clause alone.

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

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

No annotations provided, so description carries full burden. It discloses that output is in millimeters and consists of native mesh vertices/triangles, but omits whether the operation is read-only, permissions required, side effects, or return format.

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

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

Single sentence, front-loaded, no filler. It is appropriately sized for a tool description, though brevity contributes to information gaps covered 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?

No output schema and no annotation coverage, so the description should explain returns and behavior more fully. It names data type and unit but lacks project parameter semantics, return structure, and safety profile, leaving the agent with insufficient information to call confidently.

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

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

Schema coverage is 0% and the description never mentions the sole required 'project' parameter, leaving its meaning, expected format, and role unexplained. The description adds no semantic value beyond the schema.

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

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

States a specific verb 'Extract' and resources 'native mesh vertices/triangles', plus the unit 'millimeters'. It is distinguishable from inspection/render siblings by focusing on raw geometry extraction, though it does not explicitly name an alternative.

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

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

No guidance on when to use this versus bridge_inspect or bridge_verify, nor when not to use it. Use case is implied by the extraction verb but no alternatives or prerequisites are given.

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

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

With no annotations, the description carries the full burden, and 'Read' at least implies a non-mutating operation. It adds one genuinely useful behavioral fact absent from structured fields: numeric IDs are unstable across SaveAs while native UUIDs are stable. It still omits pagination behavior, result size, and 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?

Two dense sentences, front-loaded with the read action and free of filler; the ID-stability warning is placed second where it belongs. It is arguably too terse for the burden it carries, but 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?

A 5-parameter tool with zero schema descriptions, no annotations, and no output schema needs the description to explain pagination, the meaning of project/kind/details, and what a result row looks like. Almost all of that 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 0% across 5 parameters, and the description only loosely gestures at 'kind' and 'details' via mentions of parameters/definitions/quantities. limit, offset, and project are entirely unexplained, and pagination semantics for the first two are left to inference.

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 read verb and lists the data classes returned (UUIDs, parameters/definitions, quantities), which is more than a tautology. However, it never names the resource being inspected (elements, plan, model?), and does nothing to distinguish it from siblings like bridge_project_info, bridge_inspect_drawings, or bridge_geometry.

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 routing to alternatives despite a crowded sibling set. The SaveAs caveat hints at a use case (stable UUID lookup across renames) but never states it as 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?

No annotations are provided, so the description carries the full behavioral burden. It implies a read operation but says nothing about permissions, whether it mutates state, size/scope of the read, or cost, leaving the agent with essentially no behavioral context.

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

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

A single, front-loaded sentence with no filler. It is efficient, though its brevity comes at the cost of substance rather than being tight-but-complete.

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

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

For a tool with no annotations, no output schema, and an undocumented required parameter, the description is too thin. It does not tell the agent what the read returns or how to scope 'project', so the definition is incomplete for the complexity of the invocation.

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

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

Schema description coverage is 0% and the single required parameter 'project' is bare — the description doesn't clarify whether it is a name, path, GUID, or the active project. With a required parameter entirely undocumented in both schema and description, the description fails to compensate.

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

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

The verb 'Read' plus the resource 'drawing parameters and object persistent identities' signals a read-only inspection of drawing data, which is somewhat specific. However, 'object persistent identities' is opaque jargon and the description never distinguishes this from sibling inspection tools like bridge_inspect or bridge_geometry, leaving the agent to guess which inspector to pick.

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, and no mention of alternatives. With siblings such as bridge_inspect, bridge_geometry, and bridge_project_info, the absence of any routing hint 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?

With no annotations, the description carries the full burden, and it does disclose a key behavioral trait: edits land on a disposable copy and the source file is preserved. However, it omits permissions, reversibility of the copy, and what the operation returns.

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 wasted words; the preservation guarantee is stated clearly. Slightly terse given the complexity it is summarizing.

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?

No annotations, no output schema, and 0% parameter coverage leave the agent underinformed about inputs and return values for a 3-required-param tool. The description covers intent but not enough operational detail.

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 0% and all three parameters (project, output, operations) are undocumented in both schema and description. The description adds no meaning about what 'output' designates or what format 'operations' expects, failing to compensate for 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+resource ('apply proposed edits') and a distinctive scope ('to a NEW disposable native copy, preserving the saved source file'). This differentiates it in effect from direct-apply siblings like bridge_apply_plan, 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 description implies a preview/dry-run intent ('preview', 'disposable copy') but gives no explicit when-to-use, when-not-to-use, or named alternative such as bridge_apply_plan. The agent must infer the 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?

No annotations are provided, so the description carries the full burden. It implies read-only via 'Read' and hints that 'actual native' data and a 'persistent' UUID are returned, but says nothing about permissions, failure modes when the project is unknown, or whether other tools see the same values.

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

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

A single sentence with no filler, and the key content (read + resource + returned fields) is front-loaded. The phrasing is slightly clunky with the slash-separated field list, but 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 no output schema, the description usefully enumerates the returned fields, which partially covers return-value disclosure. However, the one undocumented input parameter and the absence of any annotation-equivalent behavior detail leave real gaps for a tool the agent must call with an unidentified project argument.

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

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

The single required 'project' parameter has 0% schema description coverage, and the description never explains what form it takes (name, file path, UUID). Mentioning a 'persistent project UUID' in the return fields is ambiguous and does not clarify whether the parameter accepts a UUID.

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) plus the exact resource and the fields returned (Code/Name/Stage/Description/UUID), which makes it clearly the read counterpart to bridge_set_project_info. It does not name that sibling explicitly, so differentiation is inferred from the verb rather than stated.

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 such as bridge_set_project_info or bridge_capabilities. The only usage signal is the verb 'Read', which the agent must interpret on its own.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose one meaningful trait: it is non-mutating ('Does not mutate Renga'). However, it says nothing about what the returned plan looks like, whether the operation is deterministic, or how errors are surfaced, so the disclosure is incomplete.

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 zero padding, and the core action is front-loaded before the non-mutation caveat. The brevity is efficient, though it borders on terse given how much is left unexplained.

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 4-parameter tool with zero schema descriptions, no annotations, and no output schema, the definition is far too thin. It never explains what the plan contains, what units the dimensions use, or how the result should be fed into apply_plan, leaving the agent without enough to use it confidently.

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

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

Schema description coverage is 0%, and the description adds no meaning for depth, width, height, or thickness. Units (the defaults suggest millimetres) and how the four values relate to the four walls/floor are never stated, so the schema and description together leave the parameters under-specified.

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

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

States a specific verb (Prepare) and resource (a four-wall/room/floor operation plan), and the phrase 'operation plan' implicitly links it to the sibling apply_plan/validate_plan family. The wording 'explicit generic' is slightly jargon-heavy but the agent can tell it constructs a plan rather than executing one.

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 indication of where the produced plan goes next (e.g. apply_plan or validate_plan), and no prerequisites or exclusions. The only usage signal is the negative statement that it does not mutate Renga, which hints at a pre-apply step but leaves the workflow to inference.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose a genuine trait beyond the schema: rendering happens via IScreenshotService without synthesizing mouse/keyboard/Computer Use input, which signals a non-interactive, low-side-effect operation. It omits whether an output file is overwritten, what format is produced, and any preconditions or error 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 single sentence is front-loaded with the action and free of filler, and the 'no mouse/keyboard/Computer Use' qualifier is compact. It is appropriately sized, though the extreme terseness leaves substantial gaps that a slightly longer definition should have filled.

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 tool with no annotations, no output schema, and 0% schema coverage, the description is far too thin. It explains the rendering mechanism but says nothing about required inputs, where the rendered artifact goes, or the operational context needed to call it correctly.

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

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

Schema description coverage is 0% across five parameters (project, output, width, height, entity_id), and the description supplies no meaning for any of them. With low coverage the description must compensate, and it does not mention a single parameter.

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 ('Render a native view') and identifies the underlying mechanism (IScreenshotService), which distinguishes it from UI-driven automation approaches. It stops short of explaining what a 'native view' is relative to sibling tools like bridge_export_pdf or bridge_preview_on_copy, so it is clear but not fully 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 clause 'no mouse, keyboard or Computer Use calls' implies this is the headless, non-interactive way to obtain a rendered view, which is useful implied guidance. However, it never states explicit when-to-use versus alternatives, nor any prerequisites (e.g., project must be open, entity_id selection rules).

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that the source disk file is left unchanged and that UUIDs are verified after reopen, but it omits permission/auth requirements, what 'protected' entails, and what happens on failure or UUID mismatch.

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 operation and its two key constraints with no filler. It is arguably too compressed given the jargon ('protected destination', 'UUIDs checked after reopen'), but 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 no annotations, no output schema, and 0% parameter coverage, the description should compensate for far more than it does. It documents side-effect safety on the source but leaves parameter meaning, return behavior, and failure modes unspecified.

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 neither 'project' nor 'output' is explained in the description or schema. The agent cannot tell whether 'project' is a name, ID, or path, or whether 'output' is a directory, filename, or format specifier.

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 (Native SaveAs) and resource (project file), plus the scope constraint that the destination must be NEW and protected. It does not name or contrast with plausible siblings like bridge_copy_project or bridge_preview_on_copy, so the agent gets a clear operation but no 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?

There is no explicit when-to-use or when-not-to-use guidance and no named alternative. The only inferred constraint is that the destination must be a new protected location, which is embedded in the purpose statement rather than framed as selection criteria.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that it backs up, edits, saves, verifies after reopen, and that undo is not guaranteed, which is meaningful. However, it omits failure behavior, required permissions, and exact scope of the edit, so it remains incomplete.

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 semicolon-delimited sentence that is information-dense and front-loads the main actions. It is concise but could be better structured to separate the edit operation from the backup and undo warning.

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

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

Given no annotations and no output schema, the description should provide comprehensive context. It fails to name the four fields, explain prerequisites or failure modes, or clarify how it interacts with sibling tools, leaving critical gaps for a mutating 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 schema appears to contain no documented properties, and the description mentions 'four native project metadata fields' without naming or describing any of them. This forces the agent to guess the required inputs, leaving parameter semantics largely 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 specific verbs (back up, edit, save, verify) and a resource (four native project metadata fields), making the tool's purpose clear. However, it does not differentiate itself from siblings like bridge_project_info or bridge_save_as, 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?

The description includes a warning about undo not being guaranteed, which is useful context, but gives no explicit guidance on when to use this tool versus alternatives such as bridge_project_info or bridge_save_as. It leaves the agent to infer usage conditions.

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

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

With no annotations, the description carries the full burden, and it does disclose one genuinely useful trait that structured data lacks: it spins up a new owned STA process and never touches the user's live session, implying it is a safe, non-intrusive probe. However, it says nothing about permissions, side effects on Renga itself, latency, or what a failure looks like.

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 key behavioral constraint front-loaded and no filler. It is efficient, though borderline under-specified rather than merely concise.

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

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

No output schema and no annotations exist, so the description is the only source of information about this tool — yet it never states what a 'probe' yields (installed version? reachable? healthy?) or how failures surface. For a status tool whose entire value is its return signal, this leaves a material gap.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing parameter-wise 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?

The verb 'Probe' plus the resource 'installed Renga' signals a health/status check, but the description never says what is actually being checked or returned. It does not differentiate this from lookalike siblings such as bridge_capabilities, bridge_verify, or bridge_project_info, so an agent cannot confidently route to it.

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?

'Never attach to the user's session' is a behavioral constraint, not a usage rule; it says nothing about when to call this tool versus the many other bridge_* tools. No preconditions, no alternatives, no scenario is given.

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

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

With no annotations, the description carries the full behavioral burden; it does disclose the key safety trait that validation runs 'without native mutation,' which tells the agent this is a non-mutating operation. However, it says nothing about whether it touches the live model, what errors it reports, or how the plan structure is interpreted.

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 comes first. It is efficient, though at the cost of leaving important detail unstated.

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?

No annotations, no output schema, and a required parameter with zero documented structure. For a tool whose input is a structured plan, the description should at minimum characterize the operations format or what a valid/invalid result looks like; neither is provided.

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 required 'operations' parameter is an undescribed array of bare objects. The description offers no hint about what an operation entry looks like or what shape the plan must take, so the agent is left guessing the one argument it must supply.

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: 'Validate plan structure.' It also carves out what it is not ('not a native solver preview'), which helps separate it from preview/solver siblings. It stops short of naming the mutating counterpart (bridge_apply_plan) or the verifier (bridge_verify) 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?

The negative clause ('This is NOT a native solver preview') gives a partial when-not signal, but there is no positive guidance on when to call this versus bridge_apply_plan, bridge_preview_on_copy, or bridge_verify. Usage must be inferred from the verb 'validate.'

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not say whether the tool is read-only or mutating, what permissions or project state it requires, what it returns, or what 'conservative AABB candidates only' actually constrains. For a verification tool with zero annotation coverage, this is a substantial 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?

It is a single front-loaded sentence with no padding, which is good. But the compressed jargon ('triangle calculations', 'conservative AABB candidates only') makes it dense rather than clear, so brevity comes at the cost of comprehension.

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

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

With three undocumented parameters, no annotations, and no output schema, the description should be doing far more work than it does. An agent cannot determine required inputs, expected behavior, or return values from this text alone.

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 three parameters. The phrase 'explicit targets' loosely suggests expected_areas and 'AABB candidates' hints at collision_types, but 'project' is entirely unexplained and no formats, structure, or accepted values are given. The description does not compensate for the missing schema documentation.

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

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

The description names an action (compare) and objects (native room/floor areas, triangle calculations, explicit targets), so it is more than a tautology. However, it does not clearly distinguish itself from siblings such as bridge_geometry or bridge_validate_plan, and terms like 'triangle calculations' and 'AABB candidates' are unexplained jargon that leave the exact purpose ambiguous.

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

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

There is no statement of when to use this tool versus alternatives like bridge_validate_plan or bridge_geometry, nor any prerequisites or exclusions. The only usage hint is the implicit 'verification' framing, which the agent must infer.

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