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

There are no annotations, so the description carries the full burden. It discloses meaningful return behavior ('Returns the first match plus a count of all fixtures of that type') and the canonical nature of the returned fields. However, it does not state whether the operation is read-only, how the first match is ordered, or what happens when no matching fixture exists.

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 opening sentence is front-loaded with the core purpose, and the second paragraph adds return behavior and downstream usage. The pattern example is somewhat redundant with the earlier sentence but adds a concrete illustration. Overall it is concise and each part contributes.

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 simple one-parameter design and the presence of an output schema, the description covers purpose and usage well. However, the ambiguity around inst_type semantics and missing edge-case behavior (e.g., no match found) make it less than fully complete for an agent invoking the tool.

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

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

Schema description coverage is 0%, and the description only restates 'given Inst_Type' with the example 'LTX'. It does not clarify the expected format (full type name vs shorthand), valid values, or how the inst_type string maps to fixture types, leaving the single required parameter ambiguous.

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

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

The description states a specific verb and resource: 'Find an existing fixture of a given Inst_Type, for borrowing Symbol_Name and Wattage.' This clearly communicates the tool's purpose and distinguishes it from summary/detail siblings by its borrowing intent, though it does not explicitly name any sibling 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?

It provides a clear usage context: the returned Symbol_Name and Wattage are canonical strings to use when patching another fixture via write_fixture_patch, and it includes a concrete user-pattern example. It does not mention when not to use the tool or alternatives, so it stops short of full exclusion 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?

With no annotations provided, the description carries the behavioral disclosure burden. 'Show' indicates a non-mutating read operation, and the description names the two pieces of state it exposes: the watched file and its last parsed timestamp. This is adequate for a simple getter, though it does not detail edge cases like no active file.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to understanding the tool's purpose and observable outputs.

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 getter with an output schema and clear siblings like set_active_file and list_plots, the description covers the essential information. It could mention what happens when no file is active, but the core behavior is complete enough 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?

The tool has zero parameters and an empty input schema, so there is no parameter semantics burden on the description. The baseline of 4 applies because there is nothing for the description to clarify.

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

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

The description uses a specific verb ('Show') and resource ('which XML file is being watched') plus timing info ('when it was last parsed'), making the tool's purpose immediately clear. It is implicitly distinct from sibling set_active_file, though it does not explicitly name that sibling.

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

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

The description clearly implies when to use the tool: whenever you need to know the currently watched XML file and its last parse time. It does not explicitly state exclusions or compare against alternatives, but for a simple read-only getter this context is sufficient.

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

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

With no annotations, the description carries the burden and does reasonably well: it states that only patched fixtures are included and lists each returned field. It omits the meaning of include_old and the exact filtering combination behavior, but the core read-only listing behavior is clear.

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

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

Two short sentences front-load the tool's purpose before listing output fields; every sentence adds information and there is no filler. The structure makes the scope and filters easy to parse.

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

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

The description is adequate for a simple filtered listing and the output schema covers return shape, but it does not explain include_old or route the agent to sibling tools for different fixture queries. An agent selecting between get_channels and get_fixture_details/summary would need more context.

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

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

Schema description coverage is 0%, and the description partially compensates by saying the listing is filterable by layer and/or fixture type, which maps to layer and inst_type. The third parameter, include_old, is entirely unexplained, leaving a clear gap.

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

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

Description names a concrete resource ('Channel + DMX address listing'), states it is filterable by layer/fixture type, and enumerates entry fields, so an agent can tell it is a read-only channel/address retrieval. It does not explicitly distinguish itself from sibling tools like get_fixture_details or get_fixture_summary, so it misses the top score.

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 'filterable by layer and/or fixture type' implies when the tool is appropriate, but there is no explicit when-to-use, when-not-to-use, or alternative tool guidance against the twelve siblings. 'Includes only patched fixtures' provides a scope constraint, not a usage 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 carries the full burden, and it does disclose key behaviors: aggregation, sorting by quantity descending, and separate grouping of accessories. However, it does not explain what 'include_old' does, whether the operation is read-only, or how the result is structured beyond the rollup concept. The description is accurate but 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?

The description is three short sentences with no filler. It front-loads the main purpose, then gives sorting and accessory details, each sentence adding distinct value. This is an appropriately sized, well-structured description.

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

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

Although an output schema exists, so return-value detail is unneeded, the description still leaves the include_old parameter unexplained and provides no guidance on when to choose this over sibling tools. For a one-parameter tool this is only a moderate gap, but it prevents the definition from being fully self-sufficient. A sentence about include_old and the intended use case would make it 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 coverage is 0% and the description never mentions the only parameter, include_old. The parameter name hints at including older items, but the description provides no elaboration on what 'old' means or how the default false affects results. The parameter's self-evident name earns a slight credit, but the description fails to compensate for the missing schema description.

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

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

The description states a clear purpose: a 'rental-style rollup' of fixture type, quantity, and total wattage, which identifies the resource and action. It adds distinctive details like sorting by quantity and splitting out accessories, which helps differentiate it from siblings even without naming them. However, it doesn't explicitly contrast with the related fixture tools like get_fixture_counts or get_fixture_summary, so a small clarity gap remains.

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 'rental-style rollup' implies this tool is for a specific aggregated view, but there is no explicit statement of when to use it versus the many sibling fixture tools. It does not mention any exclusions, prerequisites, or alternative tools. An agent must infer usage context from the title alone, which is insufficient.

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 behavioral disclosure. It reveals an important hidden behavior: the 'OLD' parking layer is excluded by default and can be included via include_old=True. This adds meaningful context beyond the basic counting operation.

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

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

The description is compact, front-loaded with the main purpose, and every sentence adds value. The default exclusion and include_old behavior are stated without unnecessary wording.

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 only two optional parameters and an output schema, the description covers the essential semantics and hidden default. It does not mention how layer values are specified or when to prefer sibling tools, but this is not required for a basic counts endpoint.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It does: 'layer' is described as optional scoping, and 'include_old' is explained with its default behavior and effect. This compensates well for the empty schema descriptions.

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

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

The description clearly states the action ('Counts of each fixture type') and the optional scoping to one layer. It is specific enough to understand what the tool returns, though it does not explicitly differentiate itself from siblings like get_fixture_summary.

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

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

The description gives clear context about the default exclusion of the 'OLD' parking layer and how to include it, which guides parameter use. However, it provides no guidance on when to choose this tool over sibling tools such as get_fixture_summary or get_fixture_details.

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

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

With no annotations, the description carries the full burden. It clearly signals a read operation via 'Return' and discloses the kinds of data available: Lightwright_ID, Inst_Type, Symbol_Name, Wattage, layer, and position. It does not discuss error behavior or prerequisites, but for a simple read-only lookup the key behavioral traits are evident.

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

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

The description is two sentences with no filler. The primary action is front-loaded, and the usage rationale is concise and relevant. Every sentence contributes value.

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

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

Given the tool's low complexity, the presence of an output schema, and the clear use-case framing, the description is largely complete. It could mention what happens when the UID is invalid or cannot be found, but the core information needed to call the tool correctly is present.

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

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

Schema description coverage is 0%, so the description must compensate. It adds that uid uses 'dotted form' and identifies a single fixture, which is useful but not fully specified. The lack of an example or explanation of the dotted form syntax leaves some ambiguity, so the parameter semantics are only partially fleshed out.

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: 'Return the full parsed data for one fixture by UID.' The phrase 'full parsed data' distinguishes this from the sibling get_fixture_summary, which likely returns a summary rather than full details. The scope is clearly one fixture, and the UID mechanism is named.

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 explicit when-to-use guidance: 'Use before planning a write.' It also explains why, by listing the fields the caller usually needs to confirm the correct fixture. It does not explicitly name alternatives or when not to use it, but the context is clear enough for an agent to route correctly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It lists output categories but does not state whether this is a read-only operation, what scope it applies to (active file, active plot, all data), or how include_old affects results. 'Grand totals' hints at a non-mutating summary, but important behavioral context remains missing.

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

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

The description is a single compact fragment that front-loads the key concept, 'Grand totals', followed by a precise list of what is included. There is no filler or redundancy; every word contributes to understanding 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?

The description omits essential context such as the data scope (active file/plot vs. entire project) and the meaning of include_old. Although an output schema exists, the description itself does not provide enough for an agent to correctly know when and how to invoke this tool, especially given stateful sibling tools like set_active_file and set_active_plot.

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

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

Schema description coverage is 0%, and the description does not mention the include_old parameter at all. An agent gets no help understanding what 'old' means or how the boolean changes the summary, so the parameter semantics are 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?

The description clearly identifies a summary/aggregation tool: 'Grand totals: fixture count, total wattage, layer count, device-type breakdown' tells an agent what data will be returned. It distinguishes itself from get_fixture_counts by covering totals and breakdowns, but it lacks an explicit verb, relying on the tool name for the 'get' action.

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

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

There is no guidance on when to use this tool versus siblings like get_fixture_counts, get_fixture_details, or get_layers. The phrase 'Grand totals' implies aggregate use, but the description never states a scope such as active file/plot, nor when this summary is preferred over more granular tools.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It reveals what metrics are rolled up but says nothing about side effects, read-only status, handling of old layers, or filtering behavior such as the include_old option.

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 definition is a single focused sentence that front-loads the core concept ('per-layer rollup') and immediately lists the returned metrics. There is no wasted wording or redundancy.

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

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

The output schema probably explains the return shape, but the description omits essential invocation context: what include_old means, when to prefer this tool over similar fixture queries, and whether any data is excluded or transformed. This is not complete enough for reliable autonomous selection.

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 fails to mention include_old at all, so it adds no meaning beyond the raw parameter name and default. The agent is left to guess what 'old' refers to and how the default false affects the rollup.

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

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

The description identifies a specific aggregated resource ('layers') and the data it produces: fixture count, wattage, and unique fixture types. It stops short of a clear verb and does not explicitly contrast with sibling tools, but 'per-layer rollup' is distinctive enough.

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

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

No explicit advice or when-to-use/when-not-to-use context appears, and no alternative sibling is named. The only guidance is the weak implication that this tool is for per-layer aggregate queries, which is not enough to choose between it and get_fixture_counts or get_fixture_summary.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the scope (files under the shows root), ordering (newest first), and the fields returned for each entry. This is solid transparency for a read-only listing operation, even though failure modes and path conventions are not mentioned.

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 organized into three short, purposeful parts: the core listing behavior, the entry fields, and the practical use case. Every sentence contributes new information, and the most important detail (what the tool does) is front-loaded.

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

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

An output schema exists, so the entry fields do not need to be exhaustively documented in the description. The description still covers scope, sort order, and a decision-relevant use case, making it complete enough for an agent 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?

The only parameter, limit, is not described in the text, and schema description coverage is 0%. The schema's property name and default value imply its meaning, but the description adds no additional explanation or usage nuance. Since the parameter is simple, the gap is moderate rather than severe.

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 sentence states a specific action and resource: list Lightwright XML files under the shows root, and it adds the sort order (newest first). This clearly distinguishes the tool from siblings like set_active_plot and get_active_file, which focus on selection or retrieval rather than discovery.

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 concrete use case: picking a plot when multiple shows are open or when set_active_plot returns ambiguous matches. This provides clear guidance on when to call the tool, though it does not explicitly state when not to use it or name alternative list-producing tools.

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

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

With no annotations, the description carries the behavioral disclosure burden. It communicates that the tool audits and reports rather than modifies, and it enumerates the checks performed. However, it does not state whether the operation is read-only in explicit terms, nor does it disclose the effect of the include_old parameter on 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 opening sentence establishes the purpose, and the bullet list presents the report contents with no filler or repetition. Every line earns its place.

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

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

The output schema covers return-value shape, so the description does not need to explain that. The main gaps are the undocumented include_old parameter and the lack of context about what 'the plot' refers to or whether an active plot must be set first.

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

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

Schema description coverage is 0%, and the description does not mention the include_old parameter at all. The agent receives no explanation of what 'old' refers to or when the parameter should be used, so the description adds no meaning beyond the schema's bare field 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?

The description uses a specific verb ('Audit') and resource ('the plot'), and enumerates the exact QC issue categories it reports. It is clear what the tool does, though it does not explicitly distinguish itself from sibling tools.

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

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

The description gives no guidance on when to run this tool versus alternatives, nor does it mention prerequisites such as having an active plot or file selected. It implies a plot-audit use case but leaves all usage context 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 burden of disclosing side effects, but it only describes the file's provenance and update behavior. It does not state whether the path is validated, whether the previous active file is replaced, or what happens if the file does not exist.

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

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

The description is short and front-loaded with the action; the second paragraph adds relevant context about file location and freshness rather than padding. Slightly more detail on the parameter would be welcome, but structure is clean.

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 state-changing tool with no annotations and no parameter help, the description is incomplete: it never explains that this file becomes the active context for other Lightwright tools or how the 'watcher' behaves. The output schema covers return values, but the active-file workflow is left implicit.

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

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

Schema coverage is 0% and the description never mentions the required 'path' parameter directly. The file background helps infer that path should point to the Lightwright XML, but the description does not explain path format, absolute vs relative, or that it is mandatory.

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

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

The description opens with a concrete action, 'Point the watcher at a Lightwright Data Exchange XML file,' naming the resource and making clear this is a setter rather than get_active_file. It could be more explicit about setting the active file used by subsequent tools, since 'watcher' is unexplained.

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 the intended use by explaining what the XML file is and when Vectorworks updates it, but it never states when to prefer set_active_file over sibling tools or that it should be called before operations like list_plots. This is clear context without explicit exclusions or alternatives.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden. It does well by explaining fuzzy matching, folder-name mapping, and the rule for choosing the most recently-modified XML. It does not describe failure behavior or persistence, but the core state-changing behavior is clearly stated.

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

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

The description is short, front-loaded, and contains no filler. Every sentence contributes useful information: the action, the matching behavior, the examples, and the file-selection rule.

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 setter with no annotations, the description is largely complete. It explains the operation, matching, and selection logic. Minor gaps remain around no-match or ambiguous-match behavior, but the presence of an output schema reduces the need to document return values.

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

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

Schema description coverage is 0%, so the description must compensate for the bare input schema. It does: show_name is defined as fuzzy-matched against folder names, and examples clarify expected inputs. This adds meaningful 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?

The description states a specific verb and resource: 'Switch the active plot by show name.' It also clarifies the selection mechanism (fuzzy-matched against folder names, most recently-modified XML), which distinguishes it from sibling tools like set_active_file.

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

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

The description gives clear context for when to use the tool: when the active plot should be selected by show name. It does not explicitly name alternatives or exclusions, such as 'use set_active_file for direct file selection,' but the intended use case is clearly 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 safety burden and meets it: it discloses direct XML writing, the focus-in/apply behavior, refusals for deletes/unknown fields/unknown UIDs, and the frankenfixture warning. No annotation contradiction exists.

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 long but strictly functional: purpose, args, return value, safety, and a planning sequence are each separated and front-loaded with the core purpose. No filler or repetition.

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 complex mutation tool with no annotations and minimal schema, the description covers inputs, output keys, failure/refusal modes, warnings, and cross-tool workflow. The return schema exists, and the description still names the return keys, so nothing essential 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?

Input schema has 0% description coverage and a generic additionalProperties object, so the description must fully explain the changes parameter. It does: 'list of dicts', required keys uid and fields, dotted UID format, exact XML field-name-to-string mapping, and a realistic example.

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?

First sentence names a specific verb-resource pair ('Apply field changes to fixtures') and the mechanism (Lightwright Data Exchange XML). It is clearly distinct from the read-only sibling tools like get_fixture_details and find_fixture_of_type.

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?

Includes a concrete step-by-step workflow naming get_fixture_details and find_fixture_of_type as prerequisites, and tells the agent exactly when to call write_fixture_patch. It also states what the tool refuses to do, which doubles as when-not-to-use guidance.

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