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

Annotations declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=true, but the description adds genuinely new behavioral context: it consumes Firefly Services credits (a cost signal the annotations do not carry) and returns Adobe output URLs, plus the async-job behavior when wait=false. It stops short of noting that confirm=true is required to spend credits or that download requires wait=true, but it meaningfully exceeds the annotation baseline.

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

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

Four short, front-loaded sentences with no padding; credit consumption and return format come early. The opening sentence is redundant with the title, which costs a point but the rest is efficient.

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

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

For a 12-parameter, deeply nested tool with no output schema, the description does supply the return shape (Adobe output URLs) and the sync/async switch, which is the most important missing piece. However it leaves the core ambiguity unresolved: with two other composite tools in the sibling list, an agent has no basis for picking adaptive_composite specifically, and the confirm-credit workflow is not surfaced.

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

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

Schema description coverage is 100%, so the nested object structures, seeds defaults, harmonization, shadowIntensity and the n/numVariations aliasing conflict are all already documented in the schema. The description adds only the wait=false async hint, which the schema's own description also states, so baseline 3 is correct.

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

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

The first sentence is essentially a verbatim restatement of the tool title ('Generate adaptive composite') and never explains what an 'adaptive' composite actually does or how it differs from generate_object_composite or precise_composite. The verb+resource pairing is present, but an agent cannot distinguish the three composite siblings from this text alone.

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

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

No when-to-use guidance and no reference to any of the composite siblings (generate_object_composite, precise_composite) that an agent would need to choose between. The only usage-like hint is 'Set wait=false to return an async job', which is a parameter behavior rather than tool-selection guidance.

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

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

Annotations cover the safety profile (readOnly=false, destructive=false, openWorld=true, idempotent=false), and the description adds genuinely new context: it consumes Firefly Services credits, returns Adobe output URLs, and supports an async path via wait=false. It does not mention the confirm flag requirement for spending credits, which is a notable omission for a cost-incurring 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?

Four short, front-loaded sentences with no filler; purpose comes first, followed by cost, output, and the async toggle. Tight and readable, though the async note duplicates the schema.

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

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

For an 18-parameter tool with nested objects and no output schema, the description is thin: it does not explain the credit-confirmation flow (confirm=true), the download-to-directory path, or how job results are retrieved. The rich schema compensates somewhat, but the async workflow is only half-described.

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

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

Schema description coverage is 100%, so all 18 parameters are already documented in the schema, making 3 the baseline. The description only adds the wait=false async behavior, which the schema already states, so it contributes little param-level meaning.

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

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

States a clear verb+resource (generate images) so the agent knows exactly what it produces. However, it offers no differentiation from close siblings like generate_image5, generate_similar, or generate_video, which an agent must choose between.

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 only usage guidance is 'Set wait=false to return an async job,' which is a mode toggle rather than when-to-use-this-tool guidance. There is no mention of when to prefer this over generate_image5, generate_similar, or the composite tools.

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

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

Annotations already declare openWorldHint=true and non-idempotent, non-destructive, non-readOnly. The description adds genuinely useful context beyond that: it consumes Firefly Services credits (a cost/side-effect warning not in annotations), returns Adobe output URLs, and can run asynchronously. It omits any note about the confirm-gate or how an async job is later retrieved.

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?

Four short sentences, zero filler, with the core purpose front-loaded and the operational caveats (credits, async) placed immediately after. Every sentence carries information an agent can 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?

It correctly notes that output URLs are returned, which compensates for the absent output schema. However, for a 12-parameter, credit-spending, potentially asynchronous tool, it never explains the confirm requirement, how to poll after wait=false (the get_job_status sibling), or the credit-cost/verification flow — real gaps given the tool's 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 description coverage is 100%, so the schema already documents all 12 parameters thoroughly; baseline is 3. The description adds only two marginal notes (referenceBlobs enables natural-language edits, wait=false yields async) that largely restate the schema, and never explains the interplay of confirm, seeds, or modelSpecificPayload.

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

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

States a specific verb and resource ('Generate images with Image5') and adds two distinguishing capabilities: natural-language edits via referenceBlobs and async job return. It does not, however, distinguish itself from the sibling 'generate_image' or explain which generation tool an agent should pick, leaving the intent boundary ambiguous.

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

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

It gives one concrete usage cue ('Set wait=false to return an async job') and notes the credit cost, but never states when to choose this over siblings like generate_image, generate_similar, or the composite tools. Usage is implied by capability rather than explicit.

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

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

Annotations already declare readOnly=false, openWorld=true, and idempotent=false, so the safety profile is covered. The description usefully adds three facts beyond the annotations: it consumes Firefly Services credits (a real cost implication), it returns Adobe output URLs, and wait=false yields an async job. It omits that 'confirm' must be true to actually spend credits, which is a notable gap given the cost 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?

Four short sentences, front-loaded with the operation and then the cost, return, and async facts. Each sentence is compact and there is no padding, though the opening line largely duplicates the title rather than adding information.

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

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

For a 17-parameter tool with deep nesting and no output schema, the description does state that Adobe output URLs are returned and mentions the async option, which is helpful. However, it gives no guidance on how to handle the async path (e.g., polling via get_job_status), no mention of the confirm requirement, and no direction on choosing between the many compatibility aliases.

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 94%, so the schema already documents nearly every parameter, including aliases, domain restrictions, and the confirm flag. The description adds no parameter-level meaning beyond what the schema provides, making the baseline of 3 appropriate.

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

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

The first sentence, 'Generate object composite,' is essentially the tool title restated, giving a clear verb+resource but no information that separates it from close siblings like adaptive_composite and precise_composite. The remaining sentences describe cost and return format rather than purpose, so an agent cannot tell from the description alone what this composite operation actually does with the inputs.

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

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

There is no when-to-use guidance and no explicit comparison against alternatives such as adaptive_composite, precise_composite, or generative_fill, despite several overlapping siblings. The only conditional hint is 'Set wait=false to return an async job,' which is an invocation detail rather than tool-selection guidance.

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

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

Annotations already declare non-read-only, non-idempotent, open-world behavior, but the description adds genuinely useful context the annotations lack: it consumes Firefly Services credits, returns Adobe output URLs (important given no output schema), and supports async job return. It omits that confirm=true is required to spend credits, which is a notable behavioral gate.

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?

Four short, front-loaded sentences with no filler; purpose, cost, output, and async option each get one line. Minor redundancy in restating the wait parameter already covered by the schema.

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

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

Covers the three biggest gaps for a no-output-schema tool: cost implication, return form (Adobe URLs), and async behavior. It does not mention that a source image (URL or uploadId) is effectively required, which matters 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 100%, so the baseline is 3. The description restates the wait=false async behavior already documented in the schema and adds no new parameter semantics (aliases, credit-gating via confirm, seeds/numVariations coupling are all left to the schema).

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

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

States a specific verb+resource ('Generate similar images'), which is distinguishable from generate_image (prompt-driven) in principle. However, it never says the operation is driven by a source image, so the differentiation from siblings like generative_expand/generative_fill relies on the name and schema rather than the text.

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

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

No when-to-use guidance and no alternatives named despite many closely related siblings (generate_image, generate_image5, upscale_image, generative_expand). The only conditional instruction is 'Set wait=false to return an async job', which is a parameter behavior, not tool selection guidance.

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

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

Annotations cover the safety profile (non-read-only, open-world, non-idempotent), and the description adds genuinely useful behavior beyond them: it consumes Firefly Services credits, returns Adobe output URLs, and supports an async job mode. It still omits that the confirm flag must be set true before credits are spent.

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?

Four short, front-loaded sentences with zero filler. The purpose, cost implication, return behavior, and async mode are all stated up front, and every sentence carries information.

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

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

For a nine-parameter, nested-object, credit-spending tool with no output schema, the description covers cost and return shape but omits key operational facts: that confirm=true is required to spend credits, that download requires wait=true, and that prompt/images drive the generation. 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?

Schema description coverage is 100%, so the schema already documents all nine parameters in detail. The description's only parameter-related content (wait=false → async job) merely restates what the wait property description already says, adding no new meaning.

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

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

States a specific verb and resource ('Generate video'), which cleanly separates it from image-oriented siblings like generate_image and upscale_image. It does not, however, name or distinguish itself from any specific alternative, so it stops short of a 5.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no routing to alternatives such as generate_similar or generative_expand. The only actionable hint ('Set wait=false to return an async job') is about a single parameter's mode, not about tool selection.

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?

Annotation coverage exists (readOnlyHint=false, openWorldHint=true, idempotentHint=false), but the description adds genuinely useful context beyond them: that the call consumes paid Firefly Services credits, that it returns Adobe-hosted output URLs, and that wait=false switches to async job semantics. It stops short of noting the credit-spend confirmation requirement or the relationship between async jobs and get_job_status.

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

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

Three short, front-loaded sentences with no filler; purpose, cost, return shape, and async switch appear in order of importance. Its terseness is close to under-specification rather than padding, which is preferable.

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 15-parameter tool with nested objects and no output schema, mentioning the Adobe output URLs is a helpful return-value cue. However, it omits the required source image, the credit-confirmation flag, the deprecated image.mask property, and the multiple compatibility aliases, leaving real gaps an agent must discover in the schema.

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

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

Schema description coverage is 100% and every one of the 15 parameters is documented in the schema, including aliases, deprecations, and domain restrictions, so the baseline is 3. The description's only parameter-level addition (wait=false → async) merely restates the schema's own text for wait.

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

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

States a specific verb and resource ('Expand image'), which is unambiguous about the core operation. It does not differentiate from the sibling generative_fill, which performs a closely related filling/extending operation, so an agent cannot tell the two apart from the description alone.

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

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

There is no when-to-use guidance, no prerequisites, and no pointer to alternatives such as generative_fill or the composite tools. The only conditional ('Set wait=false to return an async job') is invocation syntax, not usage guidance.

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

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

Annotations cover safety (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=true), so the bar is lower, and the description still contributes non-obvious traits: credit consumption, an output-URL return shape, and an async mode via wait=false. It does not say whether credits are consumed on failure or how long async jobs persist, but the additions are genuinely beyond the structured fields.

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

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

Three terse sentences, front-loaded with cost and return-shape information before the async hint. Only waste is the opening 'Fill image,' which merely echoes the title. No padding or hedging.

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 16-parameter, fully schema-documented, no-output-schema tool, the description covers the two things the schema cannot: return shape (Adobe output URLs) and credit cost. It omits any routing against the 13 siblings, which is the main remaining gap, but nothing needed to invoke a call correctly is missing.

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

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

Schema description coverage is 100%, so the schema already documents all 16 parameters in detail (aliases, size presets, deprecated image.mask, confirm). The description adds only the wait=false semantics, which the schema also states. Baseline 3 is appropriate when the schema carries the parameter burden.

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 opener 'Fill image' is verbatim the title, so it is close to tautological, and it never explains what 'fill' means operationally (masked-area inpainting/expansion) nor how it differs from siblings like generative_expand, generate_similar, or precise_composite. The description does add that it consumes Firefly credits and returns Adobe output URLs, which gives some concrete scope. An agent cannot confidently distinguish this tool from other image-generation siblings on the strength of the text alone.

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 only usage cue is 'Set wait=false to return an async job,' which is a mode switch rather than selection guidance. There is no statement of when to choose this tool over generative_expand or the composite tools, no prerequisites, and no exclusion conditions despite 13 siblings competing for the same intent. Cost awareness ('consumes credits') is implied but not framed as a decision factor.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety and repeat-call semantics are covered structurally. The description adds useful operational context (this is the recovery path after a polling timeout rather than a re-submit), but says nothing about what a returned job state looks like or how to interpret it while no output schema exists.

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

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

Two short sentences with zero filler, and the purpose is front-loaded ahead of the usage condition. Every clause carries information an agent needs to act.

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

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

For a one-parameter read tool with full annotation coverage, purpose and usage are complete. The one remaining gap is return semantics: with no output schema, the description could say what job states/progress it surfaces, which an agent polling a job would want to know.

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

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

Schema description coverage is 100% and the single jobId parameter is already documented as 'Job ID or URN returned by Adobe.' The description only restates that lookup is by jobId and adds no format, provenance, or error-handling detail beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource: 'Read an existing Adobe async job by jobId.' The contrast with 'submitting generation again' implicitly separates it from the generation-heavy sibling set (generate_image, generate_video, etc.), so an agent can tell this is the read-status tool without opening a schema.

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

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

Explicitly names the trigger condition ('after a polling timeout') and the alternative to avoid ('instead of submitting generation again'), which is exactly the anti-pattern an agent would otherwise fall into. Nothing about when to reach for this tool is left to inference.

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

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

Annotations already declare readOnly/idempotent/openWorld/non-destructive, so the safety profile is covered. The description adds genuinely new behavior: the optional token changes the result scope (user-specific vs project-wide) and the call returns a single page requiring start/limit iteration — neither is derivable from the annotations.

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

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

Three short sentences, zero filler, with the core purpose front-loaded and pagination guidance last. It is tight, though the auth note could be a touch more explicit about what happens without the token.

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

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

No output schema, and the page-return note covers the return shape minimally. For a 4-parameter filter tool with 0% schema coverage, the description omits sortBy and publishedState entirely, which are the main levers an agent would need to use.

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

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

Schema description coverage is 0% across 4 parameters, so the description must carry the burden. It covers start and limit for pagination but says nothing about sortBy (6 enum values) or publishedState (8 enum values), leaving half the parameters' semantics to inference from enum names alone.

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

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

States a specific verb and resource ('Read custom models available to the Adobe project') with a clear scope qualifier. It is readily distinguishable from the generation-oriented siblings, though the description never explicitly contrasts itself with 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?

Provides concrete operational guidance: FIREFLY_USER_TOKEN is optional for user-specific access, and 'use start and limit to continue' for pagination. However, it never states when to call this versus alternatives (e.g., verify_credentials, get_job_status) or any preconditions.

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

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

Annotations already declare the mutation/safety profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true, idempotentHint=false), so the bar is lower and the description clears it by adding credit consumption, the shape of the return value (Adobe output URLs), and the async escape hatch via wait=false. It stops short of documenting polling (get_job_status), cost magnitude, or the mandatory confirm flag, so it is not a 5.

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

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

Four short sentences, front-loaded with the purpose and free of filler; nothing is padded or repeated. It is efficient, though the extreme terseness leaves semantic gaps that a slightly longer description could have closed.

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

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

For a complex tool with 10 parameters, required nested objects (background, object, fillAreaMask), and no output schema, the description is far too thin. It omits the mandatory confirm flag, the URL-vs-uploadId input requirement, polling of async jobs, and any distinction from the sibling composite 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?

Schema description coverage is 100%, so the schema already documents all 10 parameters, including wait, confirm, seeds, and the n/numVariations alias exclusivity. The description's only parameter-related statement ('Set wait=false to return an async job') merely paraphrases the schema text for wait, adding no new syntax, constraints, or defaults.

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

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

The opening sentence 'Generate precise composite' is essentially a restatement of the tool title, so it does little beyond the name. It never explains what a 'precise' composite is or how it differs from closely-named siblings like adaptive_composite and generate_object_composite. The agent learns it produces a composite image, but not what distinguishes this 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?

There is no when-to-use guidance, no when-not-to-use, and no mention of the three sibling composite tools (generate_object_composite, adaptive_composite, generative_fill) that an agent must choose between. The only usage-like detail (wait=false for async) is a parameter restatement, not routing guidance, and the 'confirm' prerequisite for spending credits is never surfaced.

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

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

Annotations already declare the non-read-only, open-world, non-idempotent profile, so the description needn't restate safety. It adds genuinely new behavioral facts: the 15 MB ceiling, the accepted formats, that the returned uploadId expires after seven days, and that file content leaves the system to Adobe — a privacy-relevant disclosure not present in any structured field.

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

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

Two sentences, no filler. Constraints (formats, size) come first, then the outcome and expiry, then the external-transmission caveat — front-loaded and every clause earns its place.

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

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

With no output schema, the description usefully covers the return value and its seven-day lifetime, plus size/format limits and the external data flow. What's missing is any tie-in to how the uploadId is consumed by sibling tools, which would complete the picture for a single-param upload 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?

Only one parameter exists and schema description coverage is 100%, so the schema fully documents filePath as a local path. The description's format and size constraints apply to the file but add no syntax or path-resolution detail beyond the schema; baseline 3 is correct.

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 (Upload) and resource (local image), enumerates accepted formats and the 15 MB cap, and names the return value (uploadId). An agent can distinguish this from siblings like generate_image or upscale_image without opening the schema.

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

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

The description implies the upload produces a reference image usable downstream, but never states when to use it versus the generative siblings or that the returned uploadId is the input to them. Usage is inferable from context only, which matches the 'implied usage' level.

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

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

The description adds valuable context beyond annotations: it discloses credit consumption, output format (Adobe URLs), and async behavior via wait=false. Annotations already cover readOnlyHint=false and destructiveHint=false, so this complements them. However, it omits that confirm=true is required to actually spend credits, which is a critical behavioral gate documented only in the schema.

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

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

Three short, front-loaded sentences with zero waste. The most critical operational facts (credits, output format, async toggle) are stated immediately.

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 credit implications and no output schema, the description covers key behaviors but omits the confirm=true requirement, which is essential to avoid failed or unintended credit spends. It also doesn't mention commercial output handling or download directory behavior, though those are in the schema.

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

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

Schema description coverage is 100%, so the schema already documents all 7 parameters thoroughly, including the credit-spending confirm flag and upscaleFactor options. The description only echoes the wait parameter behavior, adding no new parameter semantics beyond the schema baseline.

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

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

States a clear verb+resource ('Upscale image') that distinguishes it from sibling generation tools like generate_similar or generative_expand. However, it does not explicitly differentiate itself from those siblings beyond the name, leaving the agent to infer the distinction.

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

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

No guidance on when to use this tool versus alternatives like generate_similar or generative_fill. The mention of wait=false hints at async behavior but does not explain when to choose sync vs async, nor does it caution about credit consumption conditions.

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

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

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds real context beyond that: it discloses the mechanism (token is checked via a custom-model API read) and explicit negative guarantees (no entitlement proof, no token disclosure), which is meaningful behavioral 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?

Three short sentences, none wasted: purpose, mechanism, then scope limits. Front-loaded and readable, though the mechanism sentence is slightly terse for the concept it conveys.

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

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

No output schema and no parameters, but the rich annotations plus the description's stated mechanism and negative guarantees give enough to call it correctly. It stops short of saying how failure surfaces or what a success result looks like, which is the only meaningful gap.

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

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

With zero parameters the baseline is 4, but the description references 'a supplied access token' while the schema exposes no properties at all, creating a mismatch an agent could act on. The mechanism note is useful, but the phantom-input reference costs a point.

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

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

States a specific verb and resource ('Verify OAuth credentials or a supplied access token') and immediately differentiates from the generate_* siblings by noting it operates 'without generating media'. An agent can identify this as the auth-check tool without opening any schema.

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

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

Usage context is only implied - one would infer this is a pre-flight check before calling generation tools, but there is no explicit 'use this when...' or reference to sibling alternatives. The limitations ('does not prove generation entitlement') hint at scope but do not guide selection.

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