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

Annotations only indicate non-read-only, open-world, and idempotent behavior. The description adds substantial useful details: it probes `/models`, falls back from Images API to chat-completions on 404/405, saves the provider to the config file, stores API keys in a gitignored file, and survives restarts.

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

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

The description is long but well-structured, front-loads the main use case, and uses a parameter list for clear scanning. Each section adds necessary behavior or context, though a few bullet items could be tightened to reduce overall length.

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 13-parameter tool with zero schema descriptions, the description covers the core workflow, required parameters, authentication, discovery, fallback behavior, persistence, and next steps via `set_default_model`. It is not fully complete because several optional parameters remain undocumented, and the behavior for duplicate provider IDs is not stated.

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 schema description coverage at 0%, the description carries the parameter-documentation burden and does so well for 8 of 13 parameters, adding constraints, examples, defaults, and interaction rules such as `api_key_env` being ignored when `api_key` is given. However, `size_style`, `extra_headers`, `include_models`, `exclude_models`, and `aspect_ratio_mode` receive no explanation, leaving some gaps.

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

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

The opening sentence names a specific verb and resource: 'Register any OpenAI-compatible image endpoint and remember it for later.' It also clarifies the tool's role relative to siblings by stating it makes the provider available to `generate_image` immediately and on future runs.

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 explicitly says when to use the tool: 'Use this when the user names an endpoint like `https://api.example.com/v1`.' It also gives concrete guidance on auth alternatives, skipping discovery with `discover=false`, and tells the agent to call `set_default_model` if multiple models are returned.

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?

Adds meaningful behavioral detail beyond the annotations: images are always written to disk, paths are returned, return_image_content can embed results for the model, ambiguous models raise an error, and provider requirements vary. This gives an agent a clear picture of side effects and output behavior.

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

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

The description is well-organized with clear sections for model selection, editing, and output. Every section earns its place, and the most action-critical information is front-loaded. It is longer than average but appropriately so for a tool with this many parameters and modes.

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

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

The description covers the core usage modes, output behavior, and model-selection nuances well. With no output schema and only sparse annotations, it leaves some parameter semantics to inference, but the most important behavioral and decision-relevant context is present. A small gap remains for the unmentioned 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 carry the parameter-semantics burden. It explains model, prompt, input_image_path(s), output_path, and return_image_content well, but leaves most of the other 16 parameters (n, seed, size, quality, background, extra_body, etc.) undocumented. The value added is solid but incomplete given the parameter count.

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: generating or editing images through an OpenAI-compatible provider. It clearly distinguishes this from the sibling tools, which are all provider/model management operations rather than image operations.

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

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

Provides concrete usage guidance: how to specify models, when aliases are valid, and to run list_models first for bare model ids. It also explains the edit mode via input_image_path. It does not explicitly discuss when not to use the tool, but the sibling tools are different enough that no exclusion is strictly needed.

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 behavior beyond annotations: it queries each provider's endpoint, filters to image models, and caches on disk. It also explains the refresh parameter as cache bypass. Annotations already cover read-only and idempotent safety, so the added detail is valuable and non-contradictory.

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 sentences with no fluff. The purpose is front-loaded, and behavioral/parameter details follow efficiently. Every sentence 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?

Given the presence of an output schema (which covers return values) and read-only annotations, the description fully explains what the tool does, how it behaves (caching, filtering), and how to control it via parameters. Nothing essential is missing for safe invocation.

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

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

Schema description coverage is 0%, so the description must fully explain parameters. It does: 'refresh' is defined as bypassing the cache, and 'provider' as limiting to one provider. This adds meaning beyond the bare type/default schema.

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

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

The description states a specific action ('Discover image-capable models') with a clear resource ('offered by configured providers') and distinguishes it from siblings like list_providers and generate_image. It leaves no ambiguity about what the tool does.

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 clear context on when to use (discover available image models) and how to adjust behavior via 'refresh' and 'provider'. It does not explicitly name alternatives or exclusion cases, but the purpose is self-evident in the sibling context, so this meets the 'clear context, no exclusions' 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds a meaningful behavioral rule: a provider only appears with configured:true once its key env var is set. This explains a conditional in the output that wouldn't be obvious from the schema alone, going 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?

The description is exceptionally lean: two sentences. The first states the purpose, the second adds a behavioral condition and a usage tip. Every phrase earns its place, and the most important information (what it lists) is front-loaded. No redundancy, 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 zero-parameter read-only tool with an output schema present, the description covers everything an agent needs: it states the purpose, explains the meaning of configured:true, and tells how to use the returned ids. Return structure and field details are presumably handled by the output schema, so nothing critical is missing.

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

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

The tool has zero parameters, and the input schema is empty with 100% coverage. Per the rubric, a zero-parameter tool gets a baseline of 4. The description doesn't add parameter-specific semantics because there are none to explain, and it correctly stays silent rather than inventing unnecessary 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?

The description opens with a specific verb and resource: 'List configured image providers' with the additional detail about API key presence. It differentiates cleanly from siblings like list_models (models, not providers) and mutations like add_provider/remove_provider, so an agent can identify this as the pure read-only 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?

The description gives a practical downstream use for the result ('Use the returned id values as the prefix in provider:model specs'), which tells the agent how to leverage the output. It doesn't explicitly contrast with sibling tools (e.g., 'when you need models, use list_models'), but the distinctive title and purpose provide clear context without exclusions.

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

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

Annotations already signal readOnlyHint=false and idempotentHint=true, and the description adds meaningful context by specifying that removal affects the config file and that even built-in presets can be removed. There is no contradiction with 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?

The description is a single well-structured sentence that front-loads the action and object, then adds the built-in presets nuance parenthetically. Every word contributes useful information with no redundancy.

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

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

For a simple one-parameter tool with an output schema and annotations, the description is minimally adequate. However, it leaves the semantics of the sole 'id' parameter and any prerequisites unstated, so it is not fully complete on its own.

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

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

The schema provides no description for the single 'id' parameter and schema coverage is 0%. The description does not explain what id should reference or how to obtain valid provider ids, so the agent must infer the parameter's meaning from the parameter name 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?

The description uses a specific verb ('Remove') and a clear resource ('a provider'), and adds the important nuance that built-in presets are included. This makes the tool's function unambiguous and distinguishes it from sibling operations like add_provider and list_providers.

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 intended use is implied: use this tool when you need to delete a provider from the config file. However, it does not explicitly state when not to use it or how it compares to add_provider/set_default_model, leaving the usage context to inference.

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

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

Annotations already indicate readOnlyHint=false and idempotentHint=true. The description adds meaningful behavioral context by disclosing that the choice is persisted to the config file and applies to future runs, making the side effect concrete.

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 plus an example, with no filler. The core behavior is front-loaded and the parameter format is explained immediately after.

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 configuration tool, the description covers the purpose, the effect, the persistence behavior, and the parameter format. There is an output schema, so return-value documentation is not needed here.

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

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

The schema only says 'model' is a string with 0% description coverage. The description compensates fully by defining the expected format as a 'provider:model' spec or alias and giving a concrete example ('example:flux-schnell').

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 ('Persist') and resource (the default model), and explicitly ties it to generate_image calls made without a model argument. This clearly differentiates it from sibling tools like list_models or add_provider.

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

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

The description gives clear context: use this tool to set the model that generate_image will fall back to when no model is provided. It does not explicitly list when not to use it or name alternatives, but the scoped usage is evident.

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