RunAPI MCP Server

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

With no annotations, the description must disclose all behavioral traits. It only states output (balance and spending metrics) without mentioning authentication needs, rate limits, or side effects, leaving significant gaps.

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, concise sentence that immediately conveys the tool's purpose. No extraneous information is present.

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 0-parameter read tool, the description is mostly adequate but lacks specificity on the 'spending metrics' (e.g., what metrics are included). Without an output schema, more detail would improve completeness.

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 input schema has no parameters (schema coverage 100%), and the description adds no parameter details. Baseline 4 applies as the schema fully covers 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 clearly states the specific action 'Return' and the exact resource 'authenticated RunAPI account balance and spending metrics'. It distinguishes from siblings like check_pricing and create_task.

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 explicit when-to-use or when-not-to-use guidance is provided. The tool's purpose is implied but not differentiated from sibling tools such as check_pricing.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only lookup and mentions 'current runtime' pricing, which suggests live rather than cached data, but it does not state permission requirements, rate limits, or whether pricing is per-call/per-unit.

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 front-loaded sentence with no wasted words. It states the action and subject immediately.

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

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

There is no output schema and no annotations, so the description should do more to explain what pricing information is returned, such as currency, units, or scope. It also does not clarify the required 'service' parameter versus the optional 'model' parameter, leaving key context missing for a tool with no structured return metadata.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds only the phrase 'model/action pair' and does not explain how 'service' relates to the other parameters, so the baseline score of 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?

The description states a specific verb and resource: return current runtime pricing for a RunAPI model/action pair. It is distinguishable from check_balance and get_model_info by focusing on pricing, but it does not explicitly name siblings. There is also a slight mismatch: the description says 'model/action pair' while the schema requires 'service' and 'action' and treats 'model' as optional.

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 no explicit guidance on when to use this tool versus alternatives such as check_balance, get_model_info, or list_models. Usage is only implied by the tool name and the phrase 'current runtime pricing'.

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

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

With no annotations, the description carries the full burden. It does disclose two real behavioral traits: a caller-generated idempotency key for safe replay of one logical creation, and optional polling for asynchronous operations. However, it says nothing about permissions, what the response contains (e.g., a task handle), or how timeouts/caps behave, which the schema only partially covers.

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 primary constraint (idempotency key) front-loaded and the optional polling behavior second. It is tight and non-redundant, though the first sentence is generic enough that it reads more as filler than as a load-bearing specification.

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 an 8-parameter tool with a nested free-form params object, no annotations, and no output schema, so the description must work harder. It never explains the params object, the service/action/model relationship, the timeout cap behavior, or what the agent gets back to later call get_task with. Substantial gaps remain for the tool's complexity.

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

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

Schema description coverage is 100%, so all eight parameters are already documented in the schema itself, making 3 the baseline. The description only echoes the idempotency-key concept and the polling/wait idea, adding no syntax, format, or defaulting detail beyond what the schema provides.

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 name is create_task and the sibling set includes get_task, yet the description says it will 'Run a RunAPI operation,' which describes execution rather than task creation. An agent can infer task submission from the idempotency key and async/polling language, but the core verb+resource pairing is muddled rather than stated. Vague rather than specific.

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

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

It notes that async operations can optionally poll until completion, which is a hint about the wait behavior, but it gives no when-to-use guidance against siblings like get_task, list_actions, or list_models, and no prerequisites such as needing a service slug from list_models. Context is implied at best.

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

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

No annotations are provided, so the description carries the full burden. 'Get' plus the enumerated outputs make the read-only, lookup nature clear, but it says nothing about failure behavior for an unknown slug, whether pricing is cached or per-request, or any auth/rate-limit characteristics.

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, front-loaded with the primary purpose and return payload, followed by the one conditional parameter rule. Nothing is 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?

With no output schema, the description usefully names the three returned artifacts (endpoint, pricing, input constraints), which is the key missing piece for a lookup tool. Only error/precondition behavior (invalid slug, prerequisite call to list_models) is left uncovered.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters including the service/action disambiguation rule. The description's 'Add service and action when the model supports multiple endpoints' restates what the schema already says rather than adding format or precedence detail.

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

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

States a specific verb and resource ('Get supported endpoint, current runtime pricing, and input constraints for a RunAPI model slug') and enumerates exactly what comes back, which separates it from list_models (enumeration) and check_pricing (pricing only). An agent can tell what this returns without opening the schema.

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

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

The second sentence gives a conditional rule for supplying service/action, but only in terms of multi-endpoint models. There is no explicit guidance on when to call this versus check_pricing or list_actions, nor that a slug must first come from list_models (that hint lives only in the schema).

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

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

No annotations, so the description carries the full burden. It implies a read ('Fetch'), but does not disclose auth requirements, rate limits, behavior for missing/expired task IDs, or whether status can be terminal.

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

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

A single front-loaded sentence with no filler; it gets to the resource and return data immediately. Slightly terse rather than padded, which is the right failure mode here.

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 3-parameter tool with 33% schema coverage, no annotations, and no output schema, the description is too thin: it never explains the required identifiers or what the task is keyed on. It leaves the agent guessing about parameters it must supply.

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 only 33%: 'service' and 'task_id' are bare strings with no description, and the description does not explain their meaning or expected format. The one documented param (action, media task routes) is not referenced or clarified by the description either.

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 (Fetch) plus the resource and the exact data returned (current status and latest payload) for a RunAPI task. Implicitly distinguishes from create_task by scoping to 'existing' tasks, though it does not name siblings explicitly.

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

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

Nothing says when to use this versus siblings; 'existing' hints that create_task is for new tasks but this is inference, not guidance. No mention of polling, retry, or what to do if the task is unknown.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states it lists endpoint names, implying a read-only operation, but does not discuss whether results are cached, paginated, or any side effects. This is insufficient for full transparency.

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 that conveys the essential purpose without any extraneous words. It is front-loaded and every word contributes meaning.

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 zero parameters, no output schema, and no annotations, the description is complete enough for the tool's simplicity. It adequately explains the output and grouping, covering the necessary context for use.

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

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

The tool has no parameters, so the baseline for this dimension is 4. The description does not need to add parameter information, and it correctly omits any, leading to a high score.

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 it lists RunAPI endpoint names grouped by output modality. It uses specific verb 'List' and resource 'endpoint names', and the grouping detail distinguishes it from sibling tools like check_balance or create_task, which have different purposes.

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 does not provide explicit guidance on when to use this tool versus alternatives. While the purpose is clear, it lacks context such as when listing endpoints is appropriate or any exclusions. The score is minimally viable.

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

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

With no annotations, the description carries the full behavioral burden. "Embedded catalog" hints that results come from local static data rather than a live service (useful), but the description never says whether the list is paginated, how large it is, whether filters combine with AND or OR, or what happens with an unknown filter value.

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 purpose followed by inputs, with no filler. It is efficient, though the second sentence spends its budget on names the schema already exposes rather than on value semantics.

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-required-parameter read-only listing tool this is close to sufficient: the agent knows what it enumerates and what it can filter on. The remaining gap is that with no output schema and no annotations, nothing describes the returned model records or how to consume them.

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, and it only repeats the three parameter names verbatim. It gives no valid value sets for `service` or `action` (only `modality` has an enum in the schema, not the description), no case-sensitivity or matching semantics, and no indication whether filters are combinable.

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 plus the data source ("List RunAPI models from the embedded catalog"), which is clearer than a bare name restatement. It only weakly distinguishes itself from siblings like get_model_info or list_actions, but the list-vs-get distinction is inferable.

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

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

The only usage signal is "Optional filters: modality, service, or action," which describes input shape rather than when to call this tool. Nothing tells the agent when to use this instead of get_model_info for lookup or list_actions for a sibling enumeration, and there are no stated exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden and does disclose meaningful traits: it is an interactive browser-based OAuth/PKCE flow and it writes the API key to a specific file path. It omits whether the call blocks while the user completes the browser step, whether existing credentials are overwritten, and how failures surface — gaps that matter for an interactive tool.

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

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

A single sentence with zero filler, front-loading the action, the mechanism, and the observable side effect. Nothing to trim and nothing buried.

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 tool with no output schema and no annotations, the description is adequate but leaves an agent guessing on interaction semantics: whether it blocks on a browser window, whether it can be called in a non-interactive environment, and what a caller should do on failure. These are non-trivial for an auth bootstrap 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%, so the `force` parameter is already fully documented as re-running browser login when the credential comes from the local config file. The description never mentions `force`, but the schema does the work, so 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 (Authenticate) plus the resource (RunAPI) and the exact mechanism (browser PKCE login flow) and its persistence side effect (~/.config/runapi/config.json). No sibling tool overlaps with authentication, so there is nothing to confuse it with; an agent can identify this as the credential-bootstrap tool 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?

Usage is only implied: an agent infers this is the tool to call when unauthenticated, but the description never says so, nor does it state prerequisites (e.g. must run before other RunAPI tools), when NOT to re-authenticate, or what the browser flow requires of the caller. There are no competing alternatives to route against, which keeps it at minimum-viable rather than worse.

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

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

No annotations exist, so the description carries the burden, and it does disclose meaningful behavior: what is returned (approved example images in media) and what is deliberately omitted (example videos, reference images). It also states the no-auth/no-cost access profile. It stops short of pagination or result-ordering behavior, which matters given two paging params.

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 the capability stated first and return/access caveats following; 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?

With no output schema and no annotations, the description supplies the key missing context: the contents of 'media' in results and the access terms. Only paging/ordering expectations are left unaddressed, a minor gap for a simple search 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 86%, so most parameters are already documented in the schema, and the description merely echoes the facets (modality, category, tags, query, model) without adding format or combining semantics such as whether facets are ANDed.

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 (search) and resource (RunAPI prompt examples) plus the dimensions available for searching, so an agent knows exactly what this retrieves. It does not explicitly contrast with siblings, but none of the listed siblings (list_models, get_task, etc.) are close substitutes, so confusion risk is low.

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?

'Free, no API key required' sets access context, but there is no explicit when-to-use/when-not or reference to an alternative tool. The searchable facets imply the use case, leaving routing to inference.

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