Bannerbear MCP by usefulapi

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

The description discloses traits not in the annotations: that the operation is additive, that it CONSUMES API quota, that it is asynchronous, and that it returns a `pending` collection whose uid must be polled while image_urls populates. That is rich behavioral context beyond the single destructiveHint annotation.

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 dense sentences, front-loaded with the core action and cost warning, then the async behavior, then the API endpoint. No filler; every clause carries actionable 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?

Despite no output schema, the description explains the return shape (pending collection with uid, image_urls map on completion) and the required follow-up call. For an async create tool, the agent has everything needed to invoke and then retrieve the result.

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 100%, so the schema already documents all four parameters (template_set, modifications, metadata, webhook_url). The description only implies template_set usage and adds no syntax or format detail beyond the schema, so the baseline 3 is 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?

Specific verb ('Generate') plus resource ('a collection of images from a template set') and scope, immediately distinguishing it from bannerbear_create_image / create_video and other create siblings. An agent can tell what resource is produced 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?

Explicitly describes the async workflow and routes the agent to bannerbear_get_collection for polling, which is clear operational context. It does not compare against the other create_* siblings or state when a collection is preferable to a single image, so it stops short of full when-to-use 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?

Goes well beyond the single destructiveHint annotation: it discloses quota consumption, the default async return shape (a `pending` image), what the caller must do next (poll by uid), and what the sync path changes (blocking call on the sync host with image_url populated). This is exactly the behavioral detail an agent needs to sequence calls correctly. The word "additive" reads as "creates a new resource" rather than modifying existing data, which is a mild tension with destructiveHint=true but not a direct contradiction.

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?

Front-loads the highest-value facts (quota consumption and async default) in the first clauses, then layers the sync option and endpoint. Every sentence carries distinct information with no padding.

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 correctly carries the return-value burden by naming the pending-image return, the uid used for polling, and image_url in the sync case. Nothing an agent needs to call and follow up on this tool is missing.

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

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

Schema coverage is 100%, so all seven parameters are already documented, including synchronous and modifications. The description reinforces the sync/async semantics but adds no syntax or format 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 ("Generate an image from a template") plus the underlying API call (POST /v2/images), which cleanly separates it from siblings like bannerbear_create_video, bannerbear_create_screenshot, and bannerbear_create_collection 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?

Gives clear operational context: async by default and the follow-up action ("poll with bannerbear_get_image"), and the synchronous:true alternative. It does not state when NOT to use it or contrast it against sibling create tools, so it stops short of a full routing instruction.

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 explicitly labels the operation 'additive', while the annotations declare destructiveHint: true — the description directly negates the structured safety signal, which is the definition of an annotation contradiction. Otherwise the description is informative (async default, polling, sync host, quota consumption), but the conflict with the annotation creates ambiguity about the tool's risk profile.

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 sentences, front-loaded with the action and the quota caveat, then the async/sync behavior, then the endpoint. Every clause carries information an agent needs; 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?

With no output schema, the description correctly carries the return-value burden by describing the 'pending' screenshot and the sync alternative, and it notes quota cost. It omits any authentication/prerequisite detail and does not resolve how the destructive annotation should be interpreted, leaving a small gap for an agent deciding whether to invoke it.

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

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

Schema description coverage is 100%, so every parameter (url, width, height, mobile, synchronous, webhook_url) is already documented in the schema, setting the baseline at 3. The description adds operational meaning to 'synchronous' by describing the sync-host/blocking path, but says nothing beyond the schema for the viewport, mobile, or webhook parameters.

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 ('Capture a screenshot of a web page') and a concrete scope (a public URL), which cleanly separates it from siblings like bannerbear_create_image, bannerbear_create_video, and bannerbear_create_collection. The API endpoint reference reinforces exactly what operation is performed.

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 explicit operational guidance: async by default with a 'pending' screenshot to poll, or synchronous:true to block for the finished result, plus a warning that the call consumes API quota. That covers the key when/how decision, but it never distinguishes this tool from sibling creation tools (e.g. why screenshot vs. create_image), so no alternatives or exclusions are 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?

Goes well beyond the single destructiveHint annotation: discloses that the call is additive, that it consumes API quota, that the response is a `pending` video with a uid, that video_url only populates on completion, and that polling is done via a named sibling. These are the behavioral facts an agent actually needs to avoid misusing the result.

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 dense sentences, front-loaded with the action and cost signal, then the async contract, then the endpoint. No filler and nothing redundant.

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 compensates by explaining the return shape (pending video + uid) and how completion is detected. Combined with full schema coverage, an agent has everything needed to call and follow up 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 100%, so every parameter is already documented in the schema. The description implies video_template via "from a video template" but adds no syntax or constraint detail for modifications, webhook_url, metadata, or input_media_url, so the schema carries the load.

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 a video from a video template") and scopes it apart from bannerbear_create_image/create_screenshot by naming the template type. The endpoint (POST /v2/videos) reinforces the resource 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?

Gives clear operational context — async creation and the need to poll with bannerbear_get_video — which tells the agent how this tool fits into a workflow. It does not explicitly contrast when to pick this over bannerbear_create_image, but the "video template" qualifier makes the boundary inferable.

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?

readOnlyHint=true already declares the safe-read profile, and the description adds the concrete return payload fields plus the underlying REST endpoint (GET /v2/account). With no output schema present, naming the returned fields is meaningful disclosure. It still omits auth/rate-limit behavior, so 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?

Two short sentences, return fields front-loaded, with the endpoint detail appended. Nothing wasted.

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

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

For a zero-parameter read tool with readOnlyHint and no output schema, the description covers the resource and its returned fields adequately. Slightly thin on auth context but sufficient to invoke correctly.

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

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

Zero parameters, so the baseline is 4; the description correctly adds no parameter detail because none is needed.

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 (get account details) and enumerates what is returned (api_usage, api_quota, paid_plan_name), which no other sibling tool covers. It is clearly distinct from the create/get_image/collection/template/video siblings, though it does not explicitly name 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 by the mention of usage/quota fields — an agent can infer this is the tool for checking plan limits — but there is no explicit when-to-use statement or prerequisites (e.g. auth). No alternatives exist among siblings, so the gap is mild.

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?

readOnlyHint=true already establishes this as a safe read, but the description goes further by disclosing the async lifecycle: status values (pending|completed|failed) and that image_urls populates only on completion. That return-shape behavior is not derivable from the annotation and is exactly what a polling agent needs. It stops short of stating polling cadence or what a failed response contains.

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 compact clauses that front-load the core action and then layer the polling purpose and response shape, plus the raw endpoint. Zero filler sentences; every clause adds usable 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 single-parameter read tool with no output schema, the description supplies the otherwise-missing return semantics (status enum, image_urls map, completion condition) and the endpoint. Only minor gaps remain, such as polling frequency or error-case detail.

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

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

With one parameter at 100% schema description coverage, the schema already documents uid fully (including its origin in a create_collection response). The description only restates it via the API path '/v2/collections/{uid}', adding no new syntax or format meaning, 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 ('Get a single collection') and immediately distinguishes it from the sibling bannerbear_create_collection by framing it as the polling endpoint for an async render. An agent can tell exactly what this returns 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?

Explicitly says 'poll this to check an async render', which gives a concrete when-to-use condition tied to the create_collection workflow. No wrong-tool exclusion is named, but there is no competing get-collection-status sibling, so the guidance is sufficient in practice.

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 only declare readOnlyHint=true, so the description carries the behavioral load and does so well by disclosing the async state machine (status: pending | completed | failed) and when image_url populates. It stops short of error handling, rate limits, or auth needs, but the polling lifecycle is genuinely useful context beyond 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?

One sentence, tightly packed with the action, the polling use case, the status values, and the API route — no filler, and the core action is front-loaded.

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

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

With no output schema, the description compensates by naming the returned status values and the image_url field, which is what an agent needs to interpret the response. Minor gaps (auth, failure recovery) remain but are not critical for this simple read 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 100% and the sole parameter already documents its origin ('from a create_image response'). The description adds no parameter-level detail beyond that, so the baseline 3 is appropriate for a single fully-documented param.

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 ('Get a single generated image') and the scope word 'single' implicitly separates it from bannerbear_list_images. The added API route (GET /v2/images/{uid}) makes the operation 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?

Tells the agent exactly when to reach for this tool: 'poll this to check an async render', which is the key usage pattern after create_image. It doesn't name alternatives or exclusions explicitly, but the async-polling context is clear.

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, so the safe-read profile is covered. The description adds useful context about what comes back (available_modifications and what they mean for generation), but says nothing about failure modes, unknown uids, or rate limits.

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

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

Two short sentences, front-loaded with the core action and payload, with the endpoint as a trailing technical note. No filler or repetition of the title.

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 carries the return-value burden and does so at a high level by naming available_modifications. For a simple one-parameter getter with full schema coverage this is nearly complete, though error/not-found behavior is unaddressed.

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 100% for the single uid parameter, so the schema already documents it. The description only echoes the path variable via the endpoint notation and adds no format or constraint detail beyond it; 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?

The description states a specific verb and resource ("Get a single template") and clarifies the payload contains available_modifications. "Single" implicitly separates it from list_templates and get_template_set, but no sibling is named explicitly, so differentiation is inferred rather than stated.

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

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

Usage is implied: fetching available_modifications tells the agent which layers it can override before generating, which maps onto the create_image flow. However, there is no explicit when-to-use, no when-not-to-use, and no named alternative (e.g., list_templates for enumeration).

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, so the safety profile is covered. The description adds that the response includes the contained templates, which is useful return-shape context, but says nothing about auth requirements, error cases when the uid is missing, or rate limits.

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 compact sentences with the action and scope front-loaded and the endpoint appended; nothing is redundant or padded.

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-resource read with one well-documented parameter and no output schema, the description covers what is fetched and what is returned. It is nearly sufficient, with only error/edge-case behavior left unstated.

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% for the single uid parameter, so the schema does the documentation work and baseline 3 applies. The endpoint string shows uid sits on the path, a minor addition but not new semantic 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?

Specific verb (Get) plus resource (a single template set) and scope (the templates it contains), which implicitly contrasts with the plural bannerbear_list_template_sets sibling. It stops short of explicitly naming the alternative tool, so differentiation requires a small inference.

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 statement of when to use this versus bannerbear_list_template_sets or bannerbear_get_template, and no prerequisites or exclusions. Retrieval by uid is implied by the endpoint reference, but that is inference rather than 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 only declare readOnlyHint=true, so the description carries the rest and does so well: it discloses the async state machine (pending | completed | failed) and that video_url only populates on completion. It doesn't mention rate limits or polling cadence, so 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?

A single dense sentence that front-loads the action, then the polling purpose, then the state values, then the endpoint. 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 one-parameter read tool with no output schema, the description supplies exactly the missing piece: the returned state values and the conditional video_url. An agent needs nothing else to call and interpret this 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 coverage is 100% and the single uid parameter is already documented in the schema as coming from a create_video response, so the description adds no new parameter meaning. 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 ('Get a single generated video') and immediately clarifies its role as an async-render poll, which cleanly separates it from siblings like bannerbear_get_image or bannerbear_get_account.

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 tells the agent when to use it ('poll this to check an async render'), which is the key workflow context. It does not name a specific alternative or state when not to use it, so it stops short of a 5.

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?

readOnlyHint=true already tells the agent this is a safe read with no side effects, so the description's main addition is the underlying endpoint GET /v2/effects. It says nothing about return shape, pagination, or whether the list is complete versus filtered, leaving limited behavioral context beyond 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?

Two short sentences with the purpose front-loaded and the endpoint appended as supporting detail. Nothing is redundant or wasted.

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

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

For a parameterless read-only list tool with no output schema, the description supplies enough to call it correctly. A brief note on what the returned effects look like (names/IDs usable in template modifications) would make it 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?

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to clarify beyond what the empty schema already conveys. No parameter syntax or constraints are needed.

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 ('image effects') with added scope ('available for use in template modifications'), which naturally separates it from sibling list tools such as list_fonts and list_templates. It does not explicitly name or contrast a sibling, so it falls just short of a 5.

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

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

The phrase 'available for use in template modifications' implies the context in which an agent would call it, but there is no explicit when-to-use, when-not-to-use, or alternative tool guidance. Usage is inferable rather than 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?

The readOnlyHint=true annotation already tells the agent this is a safe non-mutating read. The description adds the underlying API route (GET /v2/fonts), which is mildly useful context but discloses nothing about auth requirements, rate limits, or result shape. With annotations covering the safety profile, a 3 is appropriate.

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, purpose front-loaded and the endpoint detail trailing. Nothing is padded or redundant.

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 no output schema, the definition covers what the tool does and when it is relevant. It leaves a small gap by not hinting at what a font record looks like, which matters slightly since no output schema exists to fill that in.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; this is the baseline-4 case for a no-parameter tool.

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 ('List the fonts') plus the scope in which they matter ('available for use in template modifications'), which separates it from sibling list tools like list_effects and list_images. It does not explicitly name those siblings, 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?

The phrase 'available for use in template modifications' implies the context in which an agent would call this (to resolve font names before editing a template), but there is no explicit when-to-use, when-not-to-use, or alternative named. Usage is inferable rather than 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?

Annotations declare readOnlyHint=true, so the safety profile is already covered. The description adds that results are paginated and maps to GET /v2/images, which is useful but modest; it does not disclose page size, max results, ordering, or rate limits.

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

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

Two short sentences, front-loaded with the action and scope, with zero filler. The trailing 'API: GET /v2/images' is arguably redundant boilerplate but is a minor, common convenience.

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 should carry more about what a page returns (fields, pagination metadata, ordering). It covers scope and endpoint but leaves the return shape and pagination mechanics unspecified, which are the main gaps for a list 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 (page) and schema description coverage is 100%, so the schema already documents it fully. The description's '(paginated)' corroborates but adds no syntax or format detail beyond the schema, so the baseline of 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 ('List generated images in the project') and adds scope (project-level) plus pagination. It is clearly distinguishable from the singular get_image sibling, but it does not explicitly name or route against any sibling listing tool.

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

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

There is no when-to-use or when-not-to-use guidance; the agent must infer from the verb that this enumerates images rather than fetching one (get_image). No prerequisites, no mention of filters or limits that would steer 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?

readOnlyHint=true already declares the safe-read profile, lowering the disclosure bar. The description adds the non-obvious constraint that filtering/pagination is supported and names the HTTP endpoint, which is useful context, but says nothing about return format, page size defaults, or whether a missing project yields an error.

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 with no wasted words, and the purpose is front-loaded. The trailing API endpoint is somewhat redundant but harmless.

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 read-only list tool with a full schema and annotations covering the safety profile, the description covers purpose, filtering, and pagination. Minor gaps around default page size and response structure are not critical since there is no output 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 coverage is 100%, so all four parameters are fully documented in the schema. The description only restates the parameter names, adding no format, range, or interaction detail beyond what the schema provides. 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 (List) and resource (templates in the project), and clearly distinguishes itself from bannerbear_get_template (single fetch) and bannerbear_list_template_sets. An agent can tell it apart from siblings immediately.

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 through the filtering/pagination note, but offers no explicit when-to-use vs alternatives or exclusions. Adequate but does not route the agent to the correct sibling for specific retrieval needs.

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, so the safety profile is covered. The description adds the underlying API endpoint ('GET /v2/template_sets') and the relationship to collections, which are useful contextual details. However, it does not disclose pagination behavior, rate limits, or authentication requirements beyond what the annotation implies.

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 extremely concise and front-loaded: one declarative sentence followed by the API endpoint. Every element earns its place, and there is no redundant or filler language.

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 list operation with a read-only annotation and a fully documented single parameter, the description is largely complete. It identifies what is returned implicitly ('List the template sets') and notes the collection relationship. A minor gap is the lack of pagination guidance, though the schema covers the parameter.

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 single 'page' parameter is fully documented in the schema itself. The description adds no parameter-level information (e.g., pagination semantics or default behavior), which is acceptable but not additive; baseline 3 applies when the schema does the heavy lifting.

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 ('List'), a specific resource ('template sets'), and scope ('in the project'). It also distinguishes itself from the singular sibling 'bannerbear_get_template_set' by nature of listing versus getting, and the parenthetical clarifies the relationship to 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?

The description provides no explicit when-to-use or when-not-to-use guidance. It does not mention alternatives such as get_template_set or list_templates, nor does it state prerequisites or exclusions. The parenthetical 'used by collections' hints at context but does not guide tool selection.

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