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

No annotations are supplied, so the description carries the entire behavioral burden. It conveys that this is a mutating, key-scoped operation, but says nothing about permanence, idempotency, error behavior when the key is absent, or required permissions — significant gaps for a destructive 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?

A single tight sentence with the resource and key front-loaded and no filler. It is efficient, though so terse that it omits information the agent actually needs.

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 destructive two-parameter tool with no annotations, no output schema, and zero parameter documentation, the description is too thin. Nothing tells the agent about failure modes, reversibility, or argument sourcing.

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 only shows '(profile, label)' as a composite key, adding the relationship between the two params but no explanation of what a profile or label is, their format, or their source.

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 (delete the image) and pins down the exact key it operates on, '(profile, label)', which lets an agent distinguish it from list_images and render_image. It stops short of explicitly naming a sibling or contrasting scope, so it is clear but not fully differentiated.

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

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

There is no guidance on when to delete versus when to use the sibling tools, no preconditions, and no mention of what happens if no image exists for the given key. The agent must infer all usage 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?

With no annotations, the description carries the full load; 'List stored images' implies a non-destructive read, which is useful. It discloses the returned attributes but says nothing about ordering, pagination, or limits for a potentially large collection.

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, front-loaded with the verb and resource, containing the scope and return fields with no filler.

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

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

An output schema exists, so the field list need not be the description's job, and with one optional parameter the surface area is small. Ordering and volume behavior are the only real 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 coverage is 0% for the single 'profile' parameter, so the description must compensate. '(all profiles, or one)' explains that omitting or nulling the parameter returns everything, which the schema's bare anyOf/string/null does not convey; only the expected identifier format is left unspecified.

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

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

States a specific verb (List) and resource (stored images), and adds scope (all profiles, or one) plus the returned fields. An agent can separate it from render_image and delete_image, though no sibling is named explicitly.

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

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

Usage is only implied: the tool exists to enumerate images, and the parenthetical hints at the optional profile filter. There is no statement of when to prefer this over render_image or list_profiles, and no prerequisites are given.

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

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

No annotations are supplied, so the description carries the full behavioral burden, yet it discloses nothing about read-only semantics, pagination, ordering, or result volume. 'List' strongly implies a safe read, which keeps this from being a serious gap, but no real behavioral context is added.

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 zero waste; the parenthetical earns its place by telling the agent what a profile actually is.

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

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

With an output schema present, return values need not be described, and a zero-parameter list tool needs little else. The only shortfall is the absence of any behavioral note, which for this low-risk operation is minor.

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

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

The tool takes no parameters, so the baseline is 4; the schema has nothing to document and the description appropriately does not invent parameter detail.

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

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

States a specific verb ('List') and resource ('display profiles') and clarifies what a profile represents (resolution, colour mode, output format). It is clearly distinct from the render_* and *_image siblings, though it 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?

Usage is implied rather than stated: a zero-parameter enumerator is self-evidently a 'list everything' call, and no alternative or precondition is named. There is no explicit when-to-use or when-not-to-use guidance, so it lands at minimum-viable.

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 to lean on, the description carries the full burden and does well: it discloses truncation-with-ellipsis, silent dropping of overflow lines, the persistence key (profile, label), and a non-obvious `changed=false` idempotency signal that lets callers skip a refresh. What it omits is where the image is stored/served from and any auth or profile-existence requirement.

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

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

Roughly three tight sentences with zero filler: purpose first, then the behavioral caveat, then the return contract. The `changed` flag's semantics are tucked into a parenthetical, which is exactly the right weight for it.

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

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

With no annotations and no output schema, the description correctly covers the return payload and truncation behavior, which is the important half. It remains incomplete for a 7-parameter, 0%-documented tool: two parameters are unexplained and there is no statement of the storage target or what happens if the profile does not exist.

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 7 parameters, so the description must compensate. It meaningfully covers header, lines and footer, and gives (profile, label) a role as the storage key, but `description` and `invert_header` are never mentioned and no parameter's format or length limits are specified.

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

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

States a specific verb (render) and resource (card) and even enumerates the card's structure (header bar, body lines, footer), which is more concrete than `render_image` or `render_layout`. However, it never explicitly contrasts itself with those siblings, so the agent must infer the card-vs-image-vs-layout boundary from the names 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 statement of when to choose render_card over render_image or render_layout, and no prerequisites or exclusions. The only guidance ('keep it short') is a constraint on input content rather than a routing rule, leaving selection entirely to inference.

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

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

With no annotations the description carries the full burden, and it delivers real behavioral context: the top-left origin convention, pixel units, colours that 'snap to what the profile can show', and a `changed` return value implying cached/no-op semantics. It omits what happens when (profile, label) already exists and whether the store is overwritten, which keeps it short of 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?

The purpose sentence is front-loaded, followed by terse coordinate/colour rules and a compact element-type spec block. The spec block is large but earns its space given the free-form schema; the only soft spot is the dangling '(see render_card)' reference for `changed`.

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?

Return values (URL, sha256, changed) are named despite there being no output schema, and the element format is fully specified. What is missing is anything about the profile concept (a sibling list_profiles exists), label uniqueness/overwrite behavior, and the purpose of the description and background parameters.

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 so thoroughly for the critical `elements` parameter by enumerating element types and their fields. However, profile, label, background (only defaulted in the schema) and description are never explained, leaving 4 of 5 parameters semantically 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?

Specific verb+resource: 'Render a custom layout from drawing elements and store it as (profile, label)' tells an agent exactly what is produced and where it lands. It does not, however, explicitly differentiate the tool from its close siblings render_card and render_layout, which an agent must distinguish by name inference only.

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

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

There is no statement of when to use this tool versus render_card or render_layout, nor any prerequisites or exclusions. The phrase 'custom layout from drawing elements' implies a low-level primitive, but the agent is left to infer the choice entirely from sibling tool names.

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

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

With no annotations the description carries the full burden, and it delivers: overwrite-by-label semantics, truncation/overflow/no-room warning behavior, hard limits (8 levels, 120 nodes), and colour snapping to the profile. It omits any auth/permission notes and doesn't say what the full return payload is beyond `warnings`.

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?

Purpose and the critical warning-feedback loop are front-loaded, then the node vocabulary is laid out in a scan-friendly list with no filler. Given the complexity, the length is justified, though a few lines pack several rules together.

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 deeply nested, 0%-schema-coverage tool with no output schema, the description supplies nearly everything an agent needs to build a valid tree: node types, accepted keys, defaults, limits and colours. Remaining gaps are the undocumented non-root parameters and what the stored render returns besides warnings.

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 `root` is only "object, additionalProperties true", so the description's node grammar is doing essential work that the schema cannot. However, the other four parameters (`profile`, `label`, `background`, `description`) get no explanation — `background` and `description` are never mentioned at all, and valid `profile` values are left to the list_profiles sibling.

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 ("Lay out a screen from nested rows and columns") plus the storage model ("store it as (profile, label)") and explicitly excludes pixel coordinates. It does not, however, name or contrast itself with the sibling render_card, so an agent must infer the screen-vs-card 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?

Gives a genuine workflow hint — check `warnings`, fix the layout, render again, and that "same label overwrites" — which is real usage context. But it never states when to pick this tool over render_card, nor any prerequisites or when-not-to-use conditions.

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