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

Beyond the annotations (readOnlyHint=false, etc.), the description adds little behavioral context. It does not mention side effects, asynchronous behavior, return format, authentication, or failure modes, which is significant for a write operation with no output 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?

The description is a single sentence with no filler or repetition. It could be slightly clearer, but it is appropriately compact and reads naturally.

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?

This is a low-level create tool with a free-form nested body, no output schema, and minimal annotations. The description does not explain how to construct the body, what the response will be, or how this differs from high-level endpoints, leaving an agent under-equipped to call it correctly.

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

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

With only 25% schema description coverage, the description needed to compensate, but it only hints at the resource modalities and mentions a 'native body' without explaining body, label, output_json, or the full resource enum. It omits 'speech' and 'voice-clone' from the enum, adding potential confusion.

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 ('Submit') and resource ('custom image, video, audio, lip-sync, 3D, or image-edit request'), which makes the core function reasonably clear. However, it does not differentiate this tool from the sibling gptproto_request, and the phrase 'existing ... request' is slightly 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?

No guidance is given about when to use this tool versus siblings like gptproto_request. The description does not state any prerequisites, exclusions, or context that would help an agent choose this tool over alternatives.

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, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds the live/async-polling aspect, but no extra behavioral caveats such as rate limits, caching, or failure modes. With annotations doing most of the work, 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?

A single focused sentence with no filler. The main action and the full scope of the return value are given front-loaded, and every listed item adds useful detail.

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

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

Despite lacking an output schema, the description enumerates the key return categories (methods, paths, native parameters, enums, response type, async polling contract), which is enough for an agent to understand what the tool provides. It could add error or usage context, but for a one-parameter read-only describe tool this is almost complete.

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 'model' parameter is already described as 'Exact provider/model ID.' The tool description does not add parameter-level semantics beyond what the schema provides, so the high-coverage 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?

The description uses a specific verb ('Return') with a precise resource — a model's live methods, paths, native parameters, enums, response type, and polling contract. This clearly differentiates it from siblings like gptproto_models_list (listing) and gptproto_request (making calls).

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

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

The description states what the tool returns but gives no guidance on when to use it versus siblings such as gptproto_models_list or gptproto_request. There is no explicit context, prerequisite, or exclusion to help an agent choose among the sibling tools.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and state change expectations. The description adds 'live' (models are currently available) and 'broad capability' (filter is coarse-grained), which are useful beyond the annotations. It does not describe output format or pagination, but the annotation coverage lowers the burden.

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 with no filler. The primary action and filter are front-loaded in the first sentence, and the usage guidance is in the second. Every word earns its place.

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

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

The tool is simple: one optional parameter, no output schema, and annotations already establish safety. The description covers the action, scope, filtering, and a usage context. It does not explain what fields the returned list contains, but for a listing tool meant for pre-selection, the provided information is sufficient for most agents without additional 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?

Schema description coverage is 0%, so the description must compensate. It explains that 'capability' is optional and is a 'broad capability', which maps directly to the single parameter. The enum values (text, image, video, audio) are present in the schema, so the agent can see the valid options. However, the description does not clarify the default behavior when the parameter is omitted, though 'optionally filtered' implies returning all models.

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

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

The description states a clear verb ('List') and resource ('live GPTProto models'), plus an optional filter. This distinguishes it from siblings like model_describe (which focuses on a single model) and status/pricing. It does not explicitly name a sibling, but the list/describe contrast is evident.

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

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

The phrase 'Use before choosing a model' provides a clear when-to-use context, implying this tool is for initial selection. However, it does not state when not to use it, nor does it name alternatives such as model_describe for deeper details on a selected model. Guidance is present but minimal.

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, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by saying the catalog is 'live' and 'public', and it details the modes of operation (exact query, search, capability filter with sorting), which go beyond the annotations. It doesn't contradict annotations, so a 4 is appropriate for adding useful context without redundancy.

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 two sentences with zero fluff. It front-loads the core purpose ('Read GPTProto's live public price catalog') and immediately lists the main usage modes. Every word earns its place, making it efficient and easy to scan for an agent.

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

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

Given the tool's moderate complexity (7 parameters, 0 required, no output schema), the description covers the main querying mechanisms (exact, search, capability filter) and the output is 'price catalog', which implies return values. However, it doesn't explain the 'limit' and 'language' parameters' behavior, nor does it specify sorting direction (e.g., ascending by price), which might be ambiguous. It's close to complete but misses a few operational details.

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

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

Schema description coverage is low at 43% (only 'mode' and 'model' have descriptions, and 'sort' has enum but no description beyond default). The description compensates by explaining the high-level purpose of key parameters: 'query one exact provider/model' for 'model', 'search all models' for 'search', and 'filter a capability and sort by its starting price' for 'capability' and 'sort'. This adds meaningful meaning over the schema, though it could be more explicit about 'limit' and 'language'.

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

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

The description clearly states the tool reads GPTProto's live public price catalog, with explicit verbs ('Read', 'Query', 'search', 'filter') and a resource (price catalog). It distinguishes itself from siblings by focusing on pricing, whereas siblings like gptproto_models_list or gptproto_status handle model lists or status, making it easy for an agent to differentiate.

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 its query modes ('Query one exact provider/model, search all models, or filter a capability and sort by its starting price') but does not explicitly state when to prefer this over siblings, nor does it mention exclusions. While it hints at being the go-to for pricing, it lacks explicit alternatives or when-not-to-use guidance, so it's only marginally 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 cover readOnly=false, openWorld=true, idempotent=false, and destructive=false. The description adds one genuinely useful behavioral detail: official-compatible model fields have provider prefixes removed automatically. However, it does not disclose side-effect potential, response behavior, or how streaming/output_json alter results, so it only partially augments 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 dense sentences with no filler. The core action and the key automatic transformation are front-loaded, and every clause adds information needed to use the tool or understand its behavior.

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?

This is a high-complexity tool with 11 parameters, nested object types, no output schema, and non-trivial behaviors like streaming and output selection. The description does not explain required parameters, supported methods, return format, or the role of output_json, and relies too heavily on prior familiarity with the CLI 'gptproto request'.

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 only 27%, which is low, so the description needed to compensate by explaining the many parameters. It mentions 'JSON, multipart, header, and query fields' conceptually, which maps loosely to body/form/files/headers/query, but it does not explain required fields method and path, the meaning of allow_review, label, stream, or output_json, or how they interact.

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 the specific verb 'call' and the resource: a relative method/path published by gptproto_model_describe. It also distinguishes itself from the sibling describe tool by making clear it is the invocation counterpart, and the phrase 'MCP equivalent of `gptproto request`' anchors its intent unambiguously.

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

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

The description gives clear context that this tool is used for calling methods/paths previously discovered via gptproto_model_describe. It does not explicitly list exclusions or alternatives, but the 'published by gptproto_model_describe' dependency makes the intended workflow reasonably 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 establish read-only, idempotent, and non-destructive behavior. The description adds a valuable non-obvious guarantee: it never returns the API key or a custom origin. This prevents an agent from expecting sensitive values and goes beyond the generic annotation signal.

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 two sentences with the three checks front-loaded in the first sentence and a single high-value privacy caveat in the second. No filler or redundancy.

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

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

For a parameterless status tool with strong annotations, the description is almost complete. It conveys purpose and a key negative guarantee; only the exact response shape is left implicit, and there is no output schema to make it explicit.

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 schema description coverage is trivially 100%, so there is no parameter meaning for the description to add. The baseline of 4 for parameterless tools applies, and the description appropriately spends no words on 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?

The description opens with a specific verb—'Check'—and a clear resource: the MCP's configuration status. It enumerates three concrete checks (default API origin, API key existence, file uploads), which distinguishes this from sibling tools that cover models, pricing, and task operations.

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

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

The scope is clear, so an agent can infer this is for inspecting configuration state, but the description never states when to prefer it over a sibling or when to avoid it. There is no explicit workflow cue or exclusion of alternatives, leaving usage implied 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 already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety and idempotency. The description adds meaningful behavioral context beyond those annotations: it specifies the tool performs exactly one status query, never resubmits or loops internally, and is intended for recovery after an interrupted wait. This is valuable operational detail that an agent needs to know and is not present in the annotations or 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?

The description is two sentences long, with the primary purpose and distinguishing behavior front-loaded. Every word contributes value: 'exactly one status query' sets scope, 'after an interrupted automatic wait' gives context, and 'never resubmits or internally loops' clarifies behavior. There is no fluff or redundancy.

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

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

For a simple query tool with annotations covering safety, the description conveys the core purpose and behavior adequately. However, it lacks any explanation of the parameters (task_id is required but not described, and video/output_json are unexplained), and there is no output schema to clarify return values. Given that 75% of the schema is undocumented, the description should have filled that gap but does not, leaving the tool incomplete for an agent that needs to invoke it correctly.

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

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

Schema description coverage is only 25% (only the 'path' parameter has a description; task_id, video, and output_json have none). The description does not mention any parameters or their semantics. It implies task_id is the identifier but never explains it, nor does it clarify the role of video or output_json flags. With low coverage, the description was expected to compensate but does not, leaving the agent to infer parameter usage.

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 ('perform') and resource ('status query for a saved task'), and immediately distinguishes itself from sibling tools by noting it runs exactly once 'after an interrupted automatic wait' and 'never resubmits or internally loops.' This clearly separates it from gptproto_task_wait, which likely handles waiting and resubmission. The purpose is unambiguous and differentiates well.

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 states when to use it ('after an interrupted automatic wait'), providing a clear trigger condition. It also tells the agent what it does not do ('never resubmits or internally loops'), which implicitly signals that normal waiting and resubmission should go to gptproto_task_wait. However, it does not name the alternative tool explicitly or provide a direct when-not-to-use comparison, so it falls short of the top tier.

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, idempotentHint, and destructiveHint=false, covering the safety profile. The description adds behavioral context beyond annotations by mentioning tasks are 'saved locally' and that the list includes 'completed result URLs', which provides useful detail about the operation's nature and output. No 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?

The description is two sentences, front-loaded with the core purpose and followed by a clear use-case sentence. It contains no fluff, and every word adds value. Structure is optimal for agent consumption.

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 lists the returned fields, which partially compensates for the lack of an output schema. However, it doesn't explain the filtering parameters (limit, model, status, resource), pagination behavior, or what 'recent' means. Given the tool has four optional parameters and no schema descriptions, the description should offer more detail on parameter usage and potential edge cases to be fully complete.

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

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

Schema description coverage is 0%, meaning the schema provides no explanations for limit, model, status, or resource. The description does not compensate by explaining how these parameters filter the list or what values they accept. While parameter names are somewhat self-explanatory, the description offers zero guidance on using them, which is a significant gap given the low coverage.

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

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

The description clearly states the tool lists recent asynchronous tasks saved locally, specifies the exact fields returned (IDs, model, type, time, state, result URLs), and implicitly differentiates from task_get by focusing on the plural list. The verb 'list' and resource are specific and unambiguous.

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

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

The description explicitly states when to use it: 'after an interrupted tool call or in a new conversation before creating another task.' This gives a clear scenario. It doesn't explicitly name alternatives like gptproto_task_get or gptproto_task_wait, but the context implies checking existing tasks before creating new ones, which is adequate 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 readOnly, idempotent, and non-destructive behavior. The description adds valuable behavioral detail beyond those annotations: it never resubmits and is capped at 600 seconds, both important for an agent deciding whether and how to call it.

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, both information-dense and front-loaded with the core purpose, followed by key behavioral constraints. There is no filler or repetition of schema/annotation content.

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 six parameters and no output schema, the description covers the primary use case but leaves optional parameter semantics unexplained. It is minimally viable for a default task_id-only call, especially with annotations covering safety, but not fully complete for advanced usage.

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 only 17%, and the description does not compensate by explaining parameters such as interval_ms, output_json, video, or timeout_seconds. It only indirectly implies task_id through 'existing known task' and the time cap via '600 seconds'.

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

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

The description names a specific action ('Resume MCP-owned polling') and a specific target ('existing known task'), with a clear context ('after an interrupted creation call'). It also distinguishes itself from re-submission by stating 'It never resubmits', which separates it from creation/request tools.

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

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

The description provides a clear trigger condition: use this after an interrupted creation call to resume polling for an existing task. It does not explicitly name alternative tools or exclusions, but the context is specific enough to guide selection.

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