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 states the core action but does not disclose side effects, duplicate handling, error behavior (e.g., missing collection or photo), or whether the operation is reversible.

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 words. It is efficient, though it errs on the side of being slightly too terse given the absence of annotations and parameter documentation.

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 and 0% schema coverage, the description is too thin. An agent still lacks information about required preconditions, expected return behavior, and how to correctly format the photo IDs, even though an output schema exists.

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 two parameters. It clarifies that photo_ids identifies photos and collection_id identifies an existing collection, but it does not explain ID formats, the mixed string/integer type for photo_ids, or any constraints beyond 'existing'.

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 ('Add'), a resource ('photos'), and a target ('an existing collection'). It clearly differentiates from siblings like create_collection by emphasizing 'existing', so an agent can tell what this tool is for.

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

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

The word 'existing' implicitly signals that this tool is not for creating a new collection, which points toward the sibling create_collection. However, there is no explicit when-to-use guidance, no mention of prerequisites (e.g., collection must exist), and no alternative 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 behavioral disclosure burden. It states only that a preset is applied but does not disclose that this modifies or may overwrite the photo's existing develop settings, whether the change is reversible, or what happens to settings not defined in the preset.

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, focused sentence with no filler or redundancy. The verb and object are front-loaded, making it easy to parse quickly and appropriate for a simple two-parameter tool.

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

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

For a low-complexity tool with two required, self-explanatory parameters and an output schema, the bare description is minimally sufficient for an agent to attempt invocation. However, the lack of side-effect disclosure, usage boundaries, and any pointer to discover valid preset names leaves noticeable gaps, especially with no annotations.

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 parameter-level meaning beyond the self-explanatory names photo_id and preset_name. It does not explain accepted preset_name formats, case sensitivity, or how the preset is identified and matched.

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 names a specific action ('Apply'), a specific resource ('Develop preset'), and a target ('a specified photo'), which distinguishes it from preset list/get/create/compare tools. However, a sibling named 'lightroom_apply_develop_preset' exists and the description provides no differentiation between the two, so it is not fully distinct.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives like set_develop_settings, copy_develop_settings, or the similarly named lightroom_apply_develop_preset. It also does not mention prerequisites, such as needing to look up valid preset names via list_develop_presets.

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

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

There are no annotations, so the description must disclose behavior on its own. It explicitly promises a deterministic result and a per-setting diff, which is useful; 'Compare' implies a read-only operation. It does not spell out side-effect freedom, but the verb and tool family make a mutating interpretation unlikely.

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

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

One sentence carries the action, resource, result, and determinism guarantee. There is no filler, repetition, or unnecessary background.

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 the return shape, but the input specification is under-defined: with free-form object parameters and no annotations, an agent cannot know how to construct base or candidate. Overall the description is minimally viable but has clear gaps around preset representation.

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 both parameters are generic free-form objects with no property details. The description adds only that they are Develop presets and leaves unclear whether base and candidate are preset IDs, names, or preset-setting objects. This fails to compensate for the absent 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 uses a specific verb ('Compare'), identifies the resource ('two Develop presets'), and names the output ('deterministic per-setting diff'). It is distinct from sibling tools, none of which perform comparison, so an agent can select it unambiguously.

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 the exact operation and arguments, making it clear when to call this tool: when a diff of two Develop presets is needed. It does not explicitly state exclusions or alternatives, but no sibling offers comparison, so the omission is not a practical 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. It states that all Develop adjustments are copied but does not disclose that target settings will be overwritten or replaced, whether the operation is reversible, or any prerequisites. 'Sync' hints at mutation but leaves the destructive effect unstated.

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

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

One sentence with no filler; every word contributes scope and direction. The key qualifier 'all' is front-loaded and immediately signals that this is a full-copy operation.

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

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

Given the simple 2-parameter shape and the presence of an output schema, the core invocation is clear. However, the absence of any caveat about overwriting existing target adjustments and the lack of usage guidance leave the description incomplete for an agent deciding whether the tool is safe and appropriate.

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

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

The description maps source_photo_id to the photo providing adjustments and target_photo_ids to the receiving photos, and clarifies multiplicity via 'multiple target photos.' Schema description coverage is 0%, so this mapping is the only semantic cue; it does not detail acceptable ID forms or how IDs relate to other Lightroom entities.

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

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

The description states the action ('Sync'), the resource ('Develop adjustments'), and the direction (source photo to multiple target photos). This clearly distinguishes it from set_develop_settings or apply_develop_preset, which do not imply copying from another photo.

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 bulk-copy use case but never names alternatives or exclusions. An agent must infer that this is for copying all adjustments from one photo rather than setting specific settings, so the when-to-use guidance is only implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the creation action and offers no information about side effects, duplicate name handling, permissions, or whether the parent_set_id changes behavior meaningfully.

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 or redundancy. Every word contributes to the core 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?

For a simple two-parameter create operation with an output schema, the description is minimally viable: an agent can infer the basic call. However, it lacks parameter semantics, usage routing, and behavioral context, leaving notable gaps for an agent trying to invoke 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%, and the description provides no additional meaning for either parameter. 'parent_set_id' remains unexplained beyond its title, and the description does not clarify the default behavior when it is omitted.

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 ('Create') and the resource ('a new collection'), with scope ('in the active catalog'). It is easy to tell this is about creating collections rather than presets or photo exports, though it doesn't explicitly contrast it with close siblings like add_to_collection.

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

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

No guidance is given about when to use this tool versus alternatives such as add_to_collection or lightroom_create_collection. The 'active catalog' context is helpful, but there are no exclusions, prerequisites, or routing hints.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a persistent save operation but does not mention whether an existing preset with the same name is overwritten, where the preset is stored, or what side effects occur in the Lightroom catalog.

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 focused sentence with no filler and front-loads the action. It is concise, though the brevity contributes to the lack of parameter and usage detail.

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

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

Although an output schema exists, the tool still lacks essential context for correct invocation: parameter semantics are absent, the settings object is opaque, and there is no guidance about naming or folder behavior. The description is too thin to fully support an agent calling this 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%, so the description must compensate, but it only vaguely references 'specified Develop settings'. It provides no meaning for the 'name', 'folder', or the structure of the 'settings' object, especially since settings has additionalProperties true.

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 ('Save') and a specific resource ('specified Develop settings as a new preset in Lightroom Classic'). 'As a new preset' clearly distinguishes this from sibling tools like apply_develop_preset, list_develop_presets, or export_develop_preset.

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

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

There is no guidance on when to use this tool versus alternatives such as set_develop_settings or copy_develop_settings. The description implies creating a preset but does not state prerequisites, exclusions, or conditions that would select this tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses the operation is an export (read-like) but doesn't mention whether it overwrites files, what happens if the preset is missing, or whether it requires specific permissions. The word 'exact' hints at precision but lacks behavioral detail.

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, focused sentence with no filler. It front-loads the action and resource, though it could add a brief note about parameter usage without becoming verbose.

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 6 parameters, 0% schema coverage, no annotations, and an output schema present, the description is too sparse. It doesn't explain how to specify which preset to export, what the output schema contains, or edge cases. The presence of an output schema reduces the need to describe return values, but the input side remains 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%, so the description must compensate, but it doesn't explain any of the 6 parameters. The description only mentions 'custom or plugin-managed Develop preset' without clarifying how preset_name, preset_uuid, preset_scope, preset_folder, or filename relate to identifying the preset or the output file.

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 ('Export') and resource ('Develop preset backing file'), and clarifies it exports 'one exact' preset, distinguishing it from bulk export or listing operations. It doesn't explicitly name sibling tools, but the phrase 'custom or plugin-managed' and 'backing file' adds specificity.

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

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

No guidance on when to use this tool versus alternatives like get_develop_preset or list_develop_presets. The description implies usage for exporting a preset file, but doesn't state prerequisites (e.g., preset must exist, how to identify it) or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the basic operation. It does not mention whether existing files are overwritten, whether the output directory must exist, whether original photos are untouched, or what side effects writing to disk may have.

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 wasted words. It loses a point because it is so terse that it omits important usage and parameter context that should accompany a tool with no annotations.

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 no annotations and zero parameter documentation, this description is incomplete. Even though an output schema exists, an agent cannot correctly choose parameters or understand required inputs, file behavior, or valid values from the description 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%, so the description must compensate for the parameters, but it only vaguely references 'format and quality.' It does not explain photo_ids, output_dir, the quality scale, or accepted format_type values, leaving the required parameters undocumented.

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

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

The description states a specific verb ('Export'), a specific resource ('selected photos'), a destination ('to disk'), and the configurable aspects ('format and quality'). This clearly distinguishes it from siblings like import_photos, send_to_photoshop, and export_develop_preset.

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

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

No guidance is given about when to use this tool versus alternatives. It does not mention prerequisites (e.g., photos must be selected), exclusions, or when to prefer a sibling such as send_to_photoshop or export_develop_preset.

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 burden; the word 'inspect' implies a read-only lookup, which is useful. However, it does not state whether missing presets produce an error, whether no changes are made, or whether the returned data is raw/unsorted – leaving a clear gap in behavior disclosure.

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

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

The definition is a single front-loaded sentence with no filler or repetition. Every word contributes to the core meaning.

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

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

For a one-parameter getter with an output schema, the description is largely sufficient: it identifies the resource and read nature of the call. It falls short only in not addressing usage context or error behavior, which is less critical given the tool's low complexity.

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 preset_name. The only semantic signal is the schema's title 'Preset Name,' so the description adds no meaning to the single parameter and fails to compensate for the schema's lack of 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 uses the specific verb 'inspect' and identifies the resource as 'internal adjustment parameters stored inside a Develop preset.' This clearly distinguishes the tool from sibling tools like apply_develop_preset, list_develop_presets, and export_develop_preset, since it is the one that reads a preset's stored settings.

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 states what the tool does but gives no guidance on when to choose it over the many related develop-preset siblings (list, apply, create, compare, export). There is no mention of when not to use it or prerequisites such as the preset needing to exist.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It does specify the content scope of the response (which metadata categories are included), which is useful. However, it does not explicitly state that the operation is read-only, what happens with an invalid/nonexistent photo_id, or whether any authentication or Lightroom session is required.

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

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

The description is a single, front-loaded sentence that leads with the action and then lists specific metadata categories. There is no filler or repetition; every word 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?

The tool is a simple one-parameter getter, and an output schema exists, so explaining return values in the description is not necessary. However, the absence of usage routing and photo_id semantics leaves meaningful gaps, especially with no annotations to fill the safety/behavior role. The definition is minimally adequate but not fully helpful.

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

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

The schema has one parameter (photo_id) with no description at all (0% coverage). The description only says 'for a photo,' adding negligible meaning. It does not explain how to obtain a photo_id, what formats are accepted (though the schema allows string/integer), or whether the ID refers to a Lightroom catalog ID or an external reference.

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 ('Get') and a clearly delineated resource ('detailed metadata for a photo') while enumerating the exact categories of metadata returned (EXIF, camera, lens, dimensions, develop parameters). This unambiguously distinguishes the tool from sibling tools like search_photos, list_collections, or set_develop_settings.

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 vs. alternatives. The description does not mention prerequisites (e.g., needing a valid photo_id), nor does it distinguish get_photo_metadata from its sibling lightroom_get_photo_metadata or from list/search tools. The agent is left to infer usage from the tool name alone.

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

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

It discloses the fallback behavior (filmstrip if none selected), which is a key behavioral trait. But it does not mention that it is a read-only operation, nor does it explain pagination behavior or the nature of the output. With no annotations, the description carries the full burden, and this is only partially met.

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

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

One short, front-loaded sentence that captures the core action and fallback with zero waste. It is appropriately 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?

The description covers the main purpose and fallback, but omits parameter semantics entirely and does not describe return behavior (though an output schema exists). For a tool with two optional parameters, the lack of parameter documentation makes it incomplete for an agent to call 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 description does not mention the limit or offset parameters at all. The input schema provides only types and defaults, with no descriptions, and schema description coverage is 0%. Thus, the agent has no guidance on how to use these parameters, a significant gap that the description fails 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 description states the specific action ('Get'), the resource ('currently selected photos'), and the context ('in Lightroom Classic'), along with a fallback behavior (filmstrip if none selected). This clearly differentiates it from sibling tools like lightroom_search_photos or lightroom_get_photo_metadata.

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 clearly implies usage for the current selection, which is distinct from searching or metadata retrieval. However, it does not explicitly state when not to use it or name alternative tools, so it lacks explicit routing guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Import photos,' which implies a mutating action, but it does not disclose side effects (e.g., copying files, modifying metadata), prerequisites (e.g., Lightroom must be open), or error behavior. This is severely under-informative.

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 sentence, which is concise, but it is so under-specified that it is nearly a restatement of the tool name. It is not well-structured to convey necessary information; it is simply too sparse.

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

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

Given the tool has 3 parameters (one required), an output schema, and no annotations, the description is completely inadequate. It does not explain the parameters, the behavior, or the return value, leaving an agent without essential context to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention source_path, copy_to, or collection_name at all. The agent gets no help understanding what these values mean or how they affect the import.

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 action ('Import photos') and a specific destination ('into Lightroom Classic catalog'), which distinguishes it from sibling tools like export_photos or send_to_photoshop. It is not a tautology, but it lacks any detail about the source or scope.

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

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

The description gives no guidance on when to use this tool versus alternatives. It does not mention import_retouched_photo or any other sibling, nor does it state any prerequisites or conditions. The usage is implied only by 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?

No annotations are provided, so the description carries the full burden. It only says the photo is imported and organized into a collection; it does not disclose whether the collection must already exist, whether it is created automatically, whether existing photos are overwritten, or what side effects occur in the Lightroom catalog.

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

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

One sentence with no filler, front-loading the main action and immediately stating the organizing effect. Every word earns its place.

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

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

For a mutating import tool with no annotations, the description lacks preconditions: the photo must presumably have been sent out for retouching first, and the target collection's existence is unclear. Even with an output schema, an agent may not know how to invoke this correctly without 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%, so the description must compensate for the parameters. It only loosely maps 'retouched master photo' to file_path and 'collection' to collection_name, but does not explain file path requirements, accepted file types, or collection creation behavior.

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

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

States a specific verb ('Import'), resource ('retouched master photo'), destination ('Lightroom Classic'), and additional action ('organize into a collection'). The word 'back' indicates a post-retouching workflow, distinguishing it from generic import_photos and add_to_collection.

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

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

The description implies usage for re-importing a retouched master photo, but does not explicitly state when to choose this tool over siblings like lightroom_import_photos or lightroom_add_to_collection. No alternatives or exclusions are named.

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

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

There are no annotations, so the description bears the full burden of behavioral disclosure. It only states the basic add operation and does not clarify whether adding duplicates is allowed, whether the collection is modified in place, what happens on invalid IDs, or whether any destructive behavior is possible.

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 seven-word sentence with no filler. It is front-loaded with the action and object, making it immediately scannable.

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 and no schema parameter documentation, the description is too thin. It lacks prerequisites, failure behavior, and any connection to sibling tools that supply the required IDs. The presence of an output schema reduces the need to document return values, but the invocation context remains underspecified.

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 loosely maps 'photos' to photo_ids and 'existing collection' to collection_id. It does not explain acceptable ID formats, where to obtain valid photo IDs, or how collection_id relates to collection listing tools.

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

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

The description states a clear action and object: 'Add photos to an existing collection.' It effectively distinguishes itself from collection creation tools. However, it does not differentiate from the sibling 'add_to_collection', which appears to be the same operation.

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

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

No guidance is given about when to use this tool versus alternatives. It does not mention that photos should already exist in Lightroom, that the collection must already exist, or that photo IDs might come from get_selected_photos. The agent is left to infer the appropriate invocation context.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects. It only says 'Apply', implying a mutation, but does not state whether the preset replaces all existing develop settings, whether the change is reversible, or what the successful result is.

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 and contains no filler or redundant phrasing. It is not bloated, though it is terse enough that some behavioral and parameter context is missing.

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

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

The tool is simple and has an output schema, so return values need not be documented. Still, with no annotations and no parameter descriptions, the one-line description is only minimally viable and leaves the agent to infer side effects and the source of valid preset names.

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 both parameters. It confirms that photo_id identifies the photo and preset_name is a Develop preset, but it does not clarify whether the preset name must match an exact preset from list_develop_presets, how casing works, or any constraints on photo_id.

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

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

The description states a clear verb ('Apply'), a resource ('Develop preset'), and a target ('specified photo'), so an agent can tell this is an action tool rather than a list/get/create preset tool. However, it does not distinguish itself from the sibling apply_develop_preset or from manual develop-setting tools such as set_develop_settings.

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 rather than alternatives like set_develop_settings, copy_develop_settings, or the unqualified apply_develop_preset sibling. The context is entirely implied by the name, and no exclusions or prerequisites are mentioned.

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

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

With no annotations, the description carries the full burden. It adds a useful behavioral guarantee ('deterministic per-setting diff') and implies a read-only operation, but it doesn't clarify input expectations, side effects, or behavior when settings are missing or unordered.

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 12-word sentence that front-loads the operation and output. Every word earns its place; there is no filler or redundant detail.

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

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

The output schema likely covers the return format, but the critical input ambiguity and lack of usage context leave an agent unsure how to structure the required arguments. For a tool with zero schema coverage and no annotations, this is a significant gap.

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

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

Schema description coverage is 0%, so the description must compensate. It only says 'two Develop presets' and gives no detail on whether base/candidate should be preset names, IDs, or full settings objects. The schema's additionalProperties:true provides no further structure, leaving the agent to guess the argument format.

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 operation ('compare') on a clear resource ('two Develop presets') and specifies the exact outcome ('deterministic per-setting diff'). This clearly distinguishes it from sibling tools like apply, create, or export presets.

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 verb 'compare' implies when to use it, but there is no explicit guidance on when to prefer this tool over siblings like get_develop_preset or apply_develop_preset. It also doesn't mention any prerequisites or context such as whether the presets must already exist or be loaded.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It says 'sync all Develop adjustments' but does not state whether this overwrites existing Develop settings on target photos, whether the operation is reversible, or whether any permissions are required. This is a material gap for a mutating operation.

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

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

A single, tight sentence that immediately communicates the core behavior. Every word earns its place, and the source-to-target direction is front-loaded without unnecessary filler.

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

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

The description covers the basic operation but omits critical context for an agent: the destructive/overwriting nature of syncing settings, how targets are affected, and any caveats about partial or all adjustments. The output schema reduces the need to describe return values, but the behavioral gaps make this incomplete for safe invocation.

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

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

Schema description coverage is 0%, and the description only gives conceptual labels ('source photo' and 'multiple target photos') rather than clarifying how the parameters are structured or used. It adds minimal meaning beyond the raw parameter names, and the schema itself lacks descriptions.

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

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

The description states a specific verb ('Sync'), a precise resource ('Develop adjustments'), and a relationship ('from a source photo to multiple target photos'). It clearly distinguishes this from setting specific values or applying a preset, making the tool's role unambiguous.

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

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

The description implies the tool's usage context—copying all Develop adjustments from one photo to many—but it gives no explicit guidance on when to choose this over siblings such as set_develop_settings or apply_develop_preset. There are no alternative comparisons or exclusion 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 provided, the description carries the full burden of behavioral disclosure, yet it only states the action. It doesn't disclose behavior for duplicate names, whether the collection is created at root level when parent_set_id is omitted, or any error conditions. The 'active catalog' dependency is hinted at but not explained.

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 wasted words: the action and scope appear first. It is under-specified overall, but purely as a conciseness matter it is appropriately lean; one additional sentence explaining parent_set_id would have improved it without bloat.

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

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

An output schema exists, so return values are covered structurally, but the meaning of parent_set_id is entirely unexplained and no pointer to sibling list functions is provided. For a 2-parameter tool with no annotations, the description leaves a material gap in the agent's ability to invoke it correctly beyond the trivial required name.

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 zero parameter information. An agent cannot infer what parent_set_id represents, what type of parent ID is expected, or where to obtain it. This is a critical gap for correct invocation beyond the required 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 states a specific verb ('Create'), a resource ('a new collection'), and a scope ('in the active catalog'), making the action clear and distinguishable from siblings like lightroom_add_to_collection or lightroom_list_collections. However, it doesn't differentiate from the alias-like sibling create_collection or clarify the hierarchy of collections versus sets.

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

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

No guidance is given on when to use this tool versus alternatives such as lightroom_add_to_collection or when a collection set should be created first. Prerequisites, such as using lightroom_list_collections to obtain a parent_set_id, are never mentioned.

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

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

No annotations are provided, so the description must carry the behavioral disclosure burden. It only says 'Save... as a new preset'; it does not mention whether existing presets with the same name are overwritten, what happens to current Develop settings, or any required context like selecting a photo first.

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 or redundant wording. It earns its place, though it is terse enough that it sacrifices useful detail.

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

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

Given the opaque nested settings object, zero annotation coverage, and no parameter descriptions, this description is not sufficient for an agent to invoke the tool correctly. An output schema exists, so return values are not a gap, but input/behavior guidance is lacking.

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 loosely maps 'Develop settings' to the settings object and 'new preset' to name/folder, but it does not explain the required shape of the settings object, folder semantics, or naming constraints.

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 action ('Save specified Develop settings as a new preset') and names the resource ('Develop settings', 'preset', 'Lightroom Classic'). This clearly distinguishes it from related sibling operations like apply, copy, compare, or export presets.

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 this tool should be used versus alternatives such as set_develop_settings or apply_develop_preset. It does not mention prerequisites, when creation is appropriate, or any exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core action of exporting a backing file and does not mention side effects, file system behavior, permission requirements, error handling, or what happens when the preset cannot be found. This is minimally informative but not misleading.

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, focused sentence with no redundant wording. It front-loads the action and resource type, but its brevity comes at the cost of needed detail. Still, it earns the conciseness score for lack of fluff.

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

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

Despite having an output schema, the tool is complex with six parameters and no annotations or schema descriptions. The one-sentence description provides almost none of the necessary operational context—no parameter meanings, no identification strategy, no usage guidance, and no behavioral caveats. It is insufficient for an agent to reliably invoke this tool correctly.

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

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

Schema description coverage is 0% and the description does not explain any of the six parameters. It does not clarify the roles of preset_name, preset_uuid, preset_scope, preset_folder, filename, or the required destination_dir, nor how they interact. The description fails to compensate for the total lack of schema-level 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 verb ('Export') and resource ('Develop preset backing file'), with the qualifier 'one exact' indicating a specific, non-bulk operation. However, it does not differentiate this tool from the similarly named sibling 'export_develop_preset' or 'get_develop_preset', so it lacks sibling distinction.

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

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

No guidance is provided on when to use this tool versus alternatives like 'get_develop_preset', 'list_develop_presets', or 'export_develop_preset'. The description gives no context for choosing it over siblings, and no exclusions or conditions are mentioned.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It states that files are written to disk but does not disclose overwrite behavior, whether directories are created, allowed format values, or what the tool returns, and it leaves ambiguous whether 'selected photos' means the current Lightroom selection or the supplied photo_ids.

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 or redundant wording. Its brevity is a structural strength even though it under-specifies behavior and parameters.

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

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

The tool has 4 parameters, no annotations, and a sparse description, so relying on the raw schema alone is not enough. Missing information about required parameters, output directory semantics, and export behavior makes this incomplete for correct invocation.

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

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

Schema description coverage is 0%, so the description should compensate for the 4 parameters. It only maps generically to 'format' and 'quality', leaving photo_ids and output_dir unexplained, and provides no detail about valid format_type values or the quality range.

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

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

The description names a specific verb ('Export'), resource ('selected photos'), destination ('disk'), and key options ('format and quality'). However, it does not differentiate from the sibling tool 'export_photos', which appears to be the same operation under a different name.

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

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

No guidance is given about when to use this tool versus alternatives like 'lightroom_export_develop_preset' or 'lightroom_send_to_photoshop'. It also fails to mention prerequisites such as which photos are considered 'selected' or whether the output directory must already exist.

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 burden of disclosing behavior. 'Inspect' effectively communicates a read-only, non-destructive operation, and 'internal adjustment parameters' tells the agent exactly what data is exposed. It does not discuss error conditions or edge cases, but for a simple inspection tool this is adequate.

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

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

The description is a single, focused sentence with no filler. It front-loads the action and resource immediately, making it easy to parse and act on.

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

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

The tool is simple and an output schema exists, so return-value documentation is not needed. However, the description lacks usage guidance and parameter semantics, leaving the agent to infer important operational details about how to correctly invoke 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 does not explain the preset_name parameter at all. An agent can infer from the tool title that preset_name identifies a Develop preset, but the description adds no detail about whether an exact name is required, how names are matched, or what happens when the preset does not exist.

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

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

The description uses a specific verb, 'Inspect', tied to a concrete resource: 'internal adjustment parameters stored inside a Develop preset.' This clearly distinguishes the tool from sibling operations like apply, create, export, or compare, and makes the tool's unique role evident.

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

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

Usage context is implied: an agent would use this when needing to see the internal parameters of a Develop preset. However, the description provides no explicit guidance about when not to use it or which alternative sibling tool might be more appropriate, such as list_develop_presets or compare_develop_presets.

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. The verb 'Get' implies a read-only, non-destructive operation and the listed metadata categories clarify what is returned, but the description does not mention error behavior, permissions, or side effects. Adequate but minimal.

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 listed metadata category adds useful specificity, making it highly scannable for an agent.

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

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

The tool is simple with one parameter and has an output schema, so return-value details are not necessary. However, the description lacks parameter semantics and usage guidance, and the absence of annotations leaves some operational context implicit. Adequate but with clear gaps.

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

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

The schema has zero description coverage for photo_id, and the description does not explain the parameter beyond saying 'for a photo.' It adds no meaningful detail about how to obtain the ID, expected format, or constraints beyond the schema's name and type.

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

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

Description uses a specific verb 'Get' and resource 'metadata' for a photo, enumerating EXIF, camera, lens, dimensions, and develop parameters. It clearly states the tool's purpose but does not differentiate it from the sibling get_photo_metadata or address overlap with other photo-retrieval tools.

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

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

No guidance is given about when to use this tool versus alternatives. Sibling tools like get_photo_metadata and get_selected_photos may overlap, but the description does not explain when this specific metadata fetch is 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 present, the description carries the behavioral disclosure burden. It transparently states the fallback behavior when nothing is selected, which is valuable. It does not mention side effects or rate limits, but 'Get' implies a read-only operation, and no destructive or mutating behavior is hinted at.

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 that communicates the primary function and a key fallback without any filler. Every word contributes meaning, and it is appropriately concise for such a simple tool.

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

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

For a simple read-only getter with an output schema available, the description is nearly complete: it states what is returned and the no-selection behavior. It could add a note about pagination, but the 'limit' and 'offset' parameters in the schema provide that structure, and the output schema handles return shape details.

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

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

The input schema has 0% description coverage, and the description does not mention 'limit' or 'offset' at all. These parameter names are fairly self-explanatory, but the description provides no guidance on pagination semantics, maximum values, or how these interact with the filmstrip fallback, so it does not compensate for the schema's low coverage.

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

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

The description clearly identifies the core action: 'Get currently selected photos in Lightroom Classic', and adds a useful fallback behavior ('or filmstrip if none selected'). It is specific about the resource and scope, though it does not explicitly differentiate itself from the similarly named sibling 'get_selected_photos'.

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

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

The description implies when to use this tool—when the agent needs the current selection—and the filmstrip fallback adds context. However, it does not explicitly explain when to prefer this over sibling tools like 'search_photos' or 'get_photo_metadata', nor does it state when it should not be used.

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

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

No annotations are provided, so the description must fully disclose behavioral traits. The description says 'import' but does not clarify the side effects: does it copy or move files? Does it modify the catalog irreversibly? Does it require user interaction or confirmation? There is no mention of authentication or staging behavior, leaving the agent uncertain about consequences.

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

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

The description is very short and to the point, but it is under-specified rather than concise. While it is front-loaded with the primary action, it misses critical details. A minimal description for a simple tool could be acceptable, but for a tool with parameters, more context is needed. This earns a 3 because it is not verbose but leaves gaps.

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

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

The tool has an output schema (which helps), but the description provides no details on what the import does, how it handles duplicates, error conditions, or supported file types. Given the sibling tools include import_retouched_photo and import_photos, the description does not differentiate them. For a tool that mutates a catalog, this is incomplete.

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%, meaning the parameters (source_path, copy_to, collection_name) are not documented in the schema. The description must compensate by explaining these parameters and how they interact (e.g., what copy_to defaults to, how collection_name is used). It provides no parameter semantics at all, leaving the agent to guess at their meaning and required format.

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 (import) and resource (photos into Lightroom Classic catalog), which is somewhat distinct from siblings like export_photos. However, it does not specify the source of the photos or the destination beyond catalog, and could be confused with import_retouched_photo. It lacks detail on the import mode (add vs copy vs move).

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

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

The description provides no guidance on when to use this tool vs alternatives like import_retouched_photo or export_photos. It does not mention prerequisites, such as whether Lightroom must be running or whether selecting photos is required. An agent would have to infer usage from the name alone.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only states the action and collection organization, without revealing side effects such as whether the collection is created if missing, whether duplicates are created, or whether existing photos are overwritten. A mutation tool like this should provide more transparency.

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

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

A single, front-loaded sentence that wastes no words. It communicates the core action and the organizational side-effect efficiently.

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

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

For a simple two-parameter import tool with an output schema, the description covers the basic purpose. However, it omits guidance about collection existence, the relationship to send_to_photoshop, and any prerequisites like Lightroom Classic being open, leaving some gaps for an agent to infer.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by clarifying that file_path refers to a retouched master photo and that the result is organized into a collection, which maps to collection_name. However, it does not explain the default collection value, required path format, or how the collection is chosen.

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

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

The description clearly states the verb 'Import' and the resource 'retouched master photo back into Lightroom Classic,' plus the organizing action into a collection. This distinguishes it from generic import_photos and the outgoing send_to_photoshop workflow.

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 'retouched master photo back' implies the tool is for re-importing an externally edited file, which gives some context but does not explicitly name alternatives or when not to use it. No clear comparison to import_photos, add_to_collection, or create_collection is provided.

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

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

No annotations are present, so the description carries the behavioral disclosure burden. 'List' signals a non-mutating read and 'all collections and collection sets' defines scope, but there is no mention of hierarchy, ordering, catalog context, or any potential side effects.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. Every word adds meaning, making it an appropriately concise definition.

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 list tool with an output schema present, the description covers the core invocation well. The only notable absence is clarification relative to the sibling list_collections tool, but that is largely a usage-guidance concern rather than a completeness gap for the operation itself.

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 the schema is fully documented as empty, so there is no parameter meaning to explain. The description does not need to compensate for any schema gaps.

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 a specific verb ('List') and resource ('collections and collection sets') with a catalog scope. It is distinguishable from mutation tools like create_collection or set_rating, but it does not explicitly differentiate from the sibling tool list_collections.

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

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

No guidance is provided about when to use this tool versus alternatives. There is no mention of list_collections, search_photos, or other list-like tools, leaving the agent to infer appropriate usage from the tool name alone.

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

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

With no annotations, the description carries the burden of behavioral disclosure. 'List' implies a non-mutating enumeration, which is accurate, but it does not mention return format, ordering, or whether an open catalog is required. There is no contradiction, but rich behavior is not disclosed.

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

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

The description is a single, front-loaded sentence with no redundant words or filler. Every word earns its place.

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

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

For a zero-parameter list operation with an output schema, the description is mostly sufficient; the output schema can explain return values. Still, it leaves ambiguity about whether built-in presets are included and does not address the near-duplicate sibling list_develop_presets.

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 the schema coverage is effectively 100%. The description's 'all' confirms no filtering, which is useful, and the zero-parameter baseline of 4 applies.

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

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

Description uses a specific verb ('List') and resource ('Lightroom Develop presets') and scopes the operation to the catalog. However, it does not explicitly distinguish itself from the sibling list_develop_presets or clarify whether it includes both built-in and user presets.

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

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

No guidance is given on when to use this tool versus alternatives like list_develop_presets, get_develop_preset, or apply_develop_preset. The phrase 'available in the catalog' implies a read-only enumeration, but there are no explicit when-to-use or when-not-to-use instructions.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It does not state whether the operation is read-only, what happens if multiple criteria are combined, or the effect of the 'limit' parameter. It also does not mention any side effects or prerequisites. This minimal disclosure is insufficient for a search tool with no annotation safety net.

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

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

The description is a single, tightly packed sentence that front-loads the action and enumerates all key criteria without redundancy. Every word earns its place, and it is easily scannable. This is exemplary conciseness.

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

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

For a search tool with 5 parameters and an output schema, the description covers the core search semantics but misses the 'limit' parameter's behavior and any guidance on combining filters. It also does not address the existence of a similarly named sibling tool, leaving ambiguity. It is adequate for basic use but incomplete for nuanced 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%, so the description must compensate. It maps four of the five parameters to human-readable concepts: text→query, star rating→rating, pick flag→flag, color label→color_label. However, it omits the 'limit' parameter and provides no details on allowed values or formats. This partial coverage earns a 3, above the low baseline but not fully compensating for the schema gap.

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

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

The description states a specific verb ('search') and resource ('photos in Lightroom Classic'), and enumerates the search criteria (text, star rating, pick flag, color label). It is clear and unambiguous, though it does not explicitly differentiate from the sibling 'search_photos' tool, which could be a generic alternative. Thus it earns a 4 rather than 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 provides no guidance on when to use this tool versus alternatives like 'search_photos' or 'get_selected_photos'. It only states what it does, with no context for selection, no exclusions, and no mention of scenarios where another tool would be preferred. This is a clear 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 provided, the description carries the full burden of behavioral disclosure. It does not mention side effects, such as launching Photoshop, creating intermediate files, or whether the operation blocks; nor does it say if the original photo is modified. The wording 'directly into Adobe Photoshop' implies a handoff but leaves the actual behavior 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?

The description is a single, readable sentence that front-loads the core action and target application. It is appropriately concise for such a narrowly scoped tool, though its brevity comes at the cost of operational detail.

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

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

For a tool with a side effect (sending a photo to an external application) and an undocumented parameter, the description is not complete enough to enable correct invocation. It leaves out how to identify the photo, what happens after sending, and any preconditions. Although an output schema exists, it does not address these operational gaps.

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

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

The schema declares a single required parameter, photo_id, with no description and 0% schema description coverage. The tool description never explains what photo_id is, how to obtain it, or its format, leaving the agent with no semantic guidance beyond an ambiguous 'Photo Id' title.

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 ('Send a photo') and the resource flow ('from Lightroom Classic directly into Adobe Photoshop'), with a specific purpose ('advanced retouching or Firefly AI inpainting'). It is easy to understand what the tool does, though it does not explicitly contrast with sibling tools like send_to_photoshop or export_photos.

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 hints at a use case ('for advanced retouching or Firefly AI inpainting') but provides no guidance on when to use this tool versus alternatives such as export_photos or import_retouched_photo. It also omits prerequisites, like whether a photo must be selected or if Lightroom must be running.

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

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

Annotations are absent, so the description must carry the full burden of behavioral disclosure. It indicates a mutating operation but does not disclose persistence, reversibility, required photo state, permissions, or whether repeated calls overwrite existing settings. This is a meaningful gap for a write tool.

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

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

Single sentence, front-loaded with the verb and object, with field examples that clarify the settings payload. No filler or redundancy.

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

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

An output schema exists, so return values need no description, and the parameter list is small. Still, without annotations the description omits usage alternatives, mutational side effects, and value semantics for the arbitrary settings object. It is sufficient for a basic call but not fully self-contained.

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 settings object permits arbitrary additional properties. The description compensates partially by naming known valid adjustment keys, but it does not explain value units, ranges, or how photo_id should be provided. Meaningful but incomplete.

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 concrete operation — 'Set Develop adjustments directly on a photo' — and enumerates representative fields (Exposure2012, Clarity2012, Dehaze, Vibrance). This makes the tool's purpose clear and distinguishable from preset/copy operations.

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 word 'directly' implies usage in contrast to applying a preset or copying settings, and the listed adjustment names suggest individual parametric editing. However, it never names alternatives such as apply_develop_preset or copy_develop_settings, nor states when not to use this tool, leaving routing 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 behavioral disclosure. It reveals that keywords are mutated, but it does not explain what 'replace' does to existing keywords, whether the operation is destructive, what happens if a keyword is absent, or any permission/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?

A single, front-loaded sentence with no filler. Every word contributes to the core operation and target resource.

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 and no schema-level parameter descriptions, this is too thin. The critical semantics of the 'mode' parameter and the behavior of 'replace' are missing; an agent could easily misuse the tool when attempting a destructive replacement. The presence of an output schema softens the need to describe return values, but the operational gaps remain significant.

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 does clarify the roles of photo_ids ('specified photos'), keywords, and the mode semantics ('Add, remove, or replace'). However, it does not specify possible mode values, their exact behavior, or the accepted forms of photo_ids.

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 action ('Add, remove, or replace') on a clear resource ('keywords') targeting 'specified photos'. It is unambiguous about what the tool does, though it does not differentiate itself from the sibling tool 'set_keywords' when both are present.

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

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

There is no guidance on when to use this tool versus alternatives, nor when to choose 'add' versus 'remove' versus 'replace'. The description implies the general use case but provides no conditions, exclusions, or references to sibling 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 of behavioral disclosure. It usefully states the valid rating range (0 to 5) and that multiple photos can be affected, but it does not mention whether existing ratings are overwritten, whether rating 0 clears a rating, or any side effects or permissions.

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

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

A single concise sentence with all core information front-loaded. No filler or redundant phrasing.

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

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

For a simple two-parameter tool, the description covers the essential operation but lacks when-to-use guidance, overwrite semantics, and behavioral side-effect disclosure. The presence of an output schema covers return values, but operational context is still incomplete.

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%, yet the description compensates by explaining the rating scale and the multi-photo capability of photo_ids. It does not elaborate on mixed string/integer IDs, but the schema already communicates the accepted types.

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 'Set star rating (0 to 5) on one or more photos' clearly identifies the action, the target resource, and the scope. However, it does not distinguish itself from the sibling tool 'set_rating', which appears to be an alternative for the same operation.

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

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

No guidance is provided about when to use this tool versus the sibling 'set_rating' or other setter tools. The description only states what the tool does, leaving an agent without criteria for choosing between similarly named 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 of behavior disclosure. The verb 'List' indicates a read-only operation with no side effects, and the description correctly names the return scope (collections and collection sets). Given the tool's trivial zero-parameter nature, this is sufficient transparency.

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

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

The description is a single, tightly worded sentence that states the exact action and scope with no filler or redundant detail. Every word earns its place.

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

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

For a zero-parameter, side-effect-free list operation with an output schema present, the description is fully complete. An agent has everything it needs to select and invoke the tool correctly; nothing important is missing.

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

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

The tool has 0 parameters, so the baseline is 4 per the rubric. The description names the conceptual resources involved, and there are no parameters to document beyond what the empty input schema shows.

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 ('List') and a clear resource ('all collections and collection sets in the catalog'). It unambiguously distinguishes this tool from sibling mutation tools like create_collection and add_to_collection, so an agent can tell what it does without opening any schemas.

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 this tool: whenever the agent needs to enumerate collections or collection sets. There are no competing 'list' siblings, so no explicit alternatives or exclusions are needed. The context is clear even though no when-not-to-use guidance is spelled out.

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

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

With no annotations, the description carries the behavioral burden. 'List' strongly implies a read-only operation, but the description does not explicitly state that no changes are made, nor does it mention any limitations or scope details beyond 'available in the catalog.'

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 clear sentence with no filler or redundancy. It front-loads the action and the resource effectively for a simple operation.

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

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

Given the tool has no parameters and an output schema exists, the description is nearly complete for a simple listing tool. It could be slightly more helpful by clarifying whether user-created presets only or all built-in presets are included, but this is a minor 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 has zero parameters, so parameter semantics are trivially satisfied. Per the rubric, a 0-parameter tool receives a baseline of 4, and the description does not need to compensate for schema gaps.

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 a specific verb ('List') and a specific resource ('Lightroom Develop presets available in the catalog'). It is distinct from obvious siblings like get_develop_preset or apply_develop_preset, though it does not explicitly name or contrast 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?

The phrase 'List all' implies this tool is for retrieving the full set of presets rather than a single preset, but the description provides no explicit guidance about when to use it versus alternatives. Usage context is only implied, not stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only lists search criteria. It does not state whether filters combine with AND/OR, what the default limit of 100 means, whether the operation is read-only, or what constitutes a match.

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. It states the verb, resource, and filtering dimensions efficiently, making every word meaningful.

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

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

The tool is relatively simple and has an output schema, so return-value documentation is unnecessary. However, the lack of any usage guidance, sibling differentiation, or behavioral detail means the description is only minimally complete for an agent deciding between this and related Lightroom tools.

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?

Since schema description coverage is 0%, the description compensates by mapping each criterion to its parameter: query=text, rating=star rating, flag=pick flag, and color_label=color label. It omits the 'limit' parameter, but the schema default partially covers that; it does not provide value formats or allowed enums.

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 clear verb ('Search'), a specific resource ('photos in Lightroom Classic'), and enumerates the search dimensions (text, star rating, pick flag, color label). It does not, however, differentiate this tool from the sibling 'lightroom_search_photos' or clarify its relationship to 'get_selected_photos' / 'get_photo_metadata'.

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 about when to use this tool versus alternative siblings. It does not mention that 'get_photo_metadata' is better for inspecting a specific photo, nor does it state any prerequisites or exclusions. The intended usage is only implied by the word 'Search'.

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

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

There are no annotations, so the description carries the full burden of disclosing side effects and prerequisites. It only says the photo is 'sent' to Photoshop; it does not explain whether a copy is created, whether Photoshop must already be installed, whether Lightroom blocks waiting for the edit, or what happens to the original photo.

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

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

One concise sentence that front-loads the core action and destination, then adds the purpose. Every word earns its place, and there is no redundant filler or restatement of the tool name.

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

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

For a single-required-parameter action with an output schema, the description is barely adequate: an agent can infer that photo_id selects the photo and that the result appears in Photoshop. However, it omits prerequisites, side-effect behavior, and any round-trip workflow guidance, which leaves meaningful gaps.

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

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

Schema description coverage is 0% and the description does not mention photo_id at all. The single parameter is somewhat self-explanatory from its name, but the description adds no explicit guidance about how to identify the photo, accepted formats, or behavior when the photo is invalid.

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 a specific action ('send'), resource ('a photo from Lightroom Classic'), and destination ('directly into Adobe Photoshop'), plus two concrete use cases ('advanced retouching or Firefly AI inpainting'). This distinguishes it from sibling tools like export_photos, import_photos, and develop-related 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 clear context for when to use the tool: when a photo needs to go into Photoshop for retouching or Firefly inpainting. It does not explicitly name alternative tools or exclusion cases, so it stops just short of a fully explicit when-to-use / when-not-to-use guide.

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 clearly implies a mutating operation on a photo's develop state, but it does not say whether unspecified settings are reset or preserved, whether the photo must be open/selected, or whether the change is reversible.

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 sentence that front-loads the action, names the resource, and uses 'etc.' to keep the long adjustment list compact without losing meaning. There is no filler.

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

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

For a write tool with no annotations, a free-form settings object, and no schema descriptions, this description is too thin. It says what the tool does but not how to shape the settings payload, what happens to existing adjustments, or what constraints apply. The output schema covers return values, but the input side is insufficiently explained.

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 compensates partially by listing example settings keys that the free-form 'settings' object accepts. However, it provides no guidance on accepted values, ranges, units, or how photo_id should be supplied, leaving the semantics under-specified.

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

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

The description names a clear action ('Set Develop adjustments') and a target ('a photo'), then lists concrete adjustment names such as Exposure2012, Highlights2012, Dehaze, and Vibrance. This is specific, though it does not explicitly call out sibling alternatives like apply_develop_preset or copy_develop_settings.

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 'directly on a photo' hints that this tool is for setting individual raw adjustment values rather than applying a preset or copying settings, but the description never states that condition explicitly. It gives no when-to-use guidance and names no alternatives or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It honestly indicates that the tool mutates keywords in three possible ways (add, remove, replace), which is core behavioral information. However, it does not explain what 'replace' means for existing keywords, whether changes are reversible, or what the response will contain.

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

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

The description is a single, tightly-worded sentence with no filler or repetition. All three core operations are front-loaded, making the tool's purpose immediately scannable.

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 zero annotations and zero schema descriptions, a one-line summary is insufficient. The agent still lacks clarity on how mode values map to behaviors, the semantics of 'replace', and whether existing keywords are overwritten or merged. The presence of an output schema helps return-value understanding but does not fix these gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It provides loose context connecting 'keywords' and 'photos' to the action, but it never explicitly maps the mode parameter to the add/remove/replace operations, nor explains the behavior of photo_ids beyond 'specified photos'. This leaves meaningful ambiguity for a required-by-default mode 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 clearly states the action ('Add, remove, or replace') and the resource ('keywords on specified photos'), making the tool's function immediately understandable. It doesn't explicitly differentiate from siblings, but the resource is distinct enough that confusion with set_rating or set_develop_settings is unlikely.

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

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

No guidance is given about when to use this tool versus alternatives, nor any context about prerequisites or typical workflows. The agent must infer usage solely from the tool name and the brief description.

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

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

With no annotations, the description must carry the full behavioral burden. It only says 'Set', which implies mutation, but does not disclose whether the operation overwrites existing ratings, is permanent, requires permissions, or has side effects. This is a significant gap for a write 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 a single, front-loaded sentence with no filler. Every element—action, range, and target—is informative and 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?

For a simple two-parameter tool with an output schema, the description covers the core action and parameter constraints but omits behavioral context like permanence, permissions, or overwrite behavior. Given no annotations, it is adequate but leaves clear gaps that could impact correct invocation.

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

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

Schema description coverage is 0%, so the description must add meaning. It provides the rating range (0 to 5) and clarifies that photo_ids supports one or more photos. This adds value beyond the bare schema, though it leaves id types and exact rating semantics to schema 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?

The description uses a specific verb ('Set') and resource ('star rating') with an explicit range (0 to 5) and target ('one or more photos'). It clearly differentiates from sibling tools like set_keywords or set_develop_settings by naming the exact property being modified.

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

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

The description implies usage when the agent wants to assign a star rating to photos, but it does not explicitly state when not to use it or mention alternative tools. There is no guidance on prerequisites or exclusions, leaving selection largely to the agent's interpretation.

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