SLXD AI API Pricing

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

With readOnlyHint=true the safety profile is already covered, and the description adds genuine behavioral context: credits are never converted to money (a real interpretation constraint) and colliding dimension labels carry qualifiers, e.g. 'Web search (context size: high)'. It stops short of noting rate limits or the exact output structure, but it meaningfully exceeds the 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 tight sentences, front-loaded with what the tool returns before moving to the two output caveats. Every sentence carries content; the label-collision example is slightly niche but directly aids result interpretation.

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, so the description must convey the return shape; it communicates the comparative format, the credit caveat, and label disambiguation, which is helpful. It still leaves the actual compared dimensions and result structure vague, which is a notable gap for a comparison tool with 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?

The description says nothing about the single `models` parameter, and per the context signal schema description coverage is 0%, so the description fails to compensate for the documented gap. It does not mention the 2-8 item bounds or the `provider/slug` format that the agent must supply.

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: 'Returns the current prices of several models side by side.' This clearly separates it from single-model retrieval siblings like get_model_price, though it never names those siblings explicitly. An agent can grasp the comparison scope 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 implied by the word 'several' and the side-by-side framing, and the credit-vs-token caveat hints at when results are meaningful. However, no alternative tool is named and there is no explicit when-not guidance, so the agent must infer this is the multi-model counterpart to get_model_price.

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 is a safe read. The description adds genuine behavioral context beyond the annotation by disclosing that the tool reports live health (when each source last succeeded and whether any is currently failing), which is not derivable from the annotation or the empty 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?

Two sentences, front-loaded with the resource and its fields, then a single usage directive. No filler, no restatement of the name or 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 parameters, no output schema, and only a readOnly annotation, the description must define the return surface itself, and it does so completely by listing sources, weight, licence, last-success timing, and failure state. Nothing an agent needs to call this correctly 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 takes zero parameters, so the schema has nothing to document and the description carries no parameter burden. Baseline 4 applies; the description instead spends its words on return content, which is the appropriate focus for a no-arg 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 resource (price sources) and enumerates exactly what it reports: which sources are consulted, their weight, licence, last success, and current failure status. This clearly distinguishes it from get_model_price and price_history, which deal with the prices themselves rather than their provenance.

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?

"Use this to judge how much to trust a price" gives a clear condition for invocation, tying the tool to a trust/provenance decision. It stops short of naming alternatives (e.g., get_model_price) or stating when-not-to-use, so it doesn't reach 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?

Annotations already declare readOnlyHint and idempotentHint, so safety is covered. The description adds genuinely useful context beyond that: the catalogue is broader than the listed tools, and the result (names plus short descriptions) is a discovery artifact that must be followed by tool_schema/run_tool rather than executed directly. No rate limits or result-count behavior are disclosed, which keeps it short of a 5.

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

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

Three short sentences, fully front-loaded: capability first, then the when-to-use condition, then the follow-up workflow. Every sentence carries information an agent needs to act, and none is 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 single-parameter, read-only search tool with annotations covering safety, the description supplies the missing pieces: what is searched, what comes back, and the mandatory next steps. With no output schema, it still tells the agent the shape of the response, so nothing needed to invoke or use the tool correctly is absent.

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 schema itself documents the keyword syntax, example, and matching rule (matched against names and descriptions, any term may match). The description's 'by keyword' only restates that, so it adds nothing beyond the structured field — the baseline 3 for full coverage 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?

States a specific verb and resource ('searches the full catalogue of available tools by keyword') and names the return payload ('matching tool names with a short description'). This clearly differentiates it from the sibling tools, all of which operate on models, prices, or providers rather than on the tool catalogue itself.

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 states the triggering condition ('when no directly-listed tool fits the task — many tools are available but not listed') and then routes the agent through the follow-up chain: call tool_schema for the picked tool, then run_tool to execute. Both alternatives are named siblings, leaving nothing 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?

Beyond the readOnlyHint annotation, it discloses rich behavioral detail: the exact dimensions returned (input, output, cached reads, tiers, context brackets), that a confidence level and agreeing sources accompany them, and that a non-selling channel returns the model with no prices. That last point is a genuinely useful edge-case disclosure the annotations do not cover.

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 return contents before the channel nuance, and each sentence carries distinct information. The closing note on colliding labels is slightly niche but earns its place as return-shape guidance.

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 burden of describing return content and does so: it enumerates the price dimensions, the confidence/source metadata, and the channel-driven outcome. An agent has enough to call it and interpret the response.

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 schema already documents the channel enum thoroughly, so the baseline is 3. The description adds meaning by framing the default as maker pricing vs. reseller rates and by spelling out the empty-result outcome, though it does not add format details beyond the 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?

Starts with a specific verb+resource: 'Returns every current price for one model', and the word 'current' implicitly separates it from the sibling price_history while the per-model scope separates it from compare_models. An agent can tell what it fetches 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?

Explains the default behavior (maker's own prices) and the condition that switches to reseller pricing via `channel`. It stops short of naming siblings explicitly (e.g. price_history for past prices, compare_models for cross-model comparison), so the agent must infer those boundaries.

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 covers the safety profile, so the description's job is lighter. It adds genuine context beyond the annotation: the return content (providers with per-provider model counts) and the provider/channel taxonomy that governs interpretation of the results. No pagination or rate-limit detail, but the conceptual framing is the valuable part here.

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 operation and payload before the taxonomy caveat. The parenthetical channel list (Vertex, Bedrock, Azure, OpenRouter) is slightly dense but earns its place by making the counter-example concrete.

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 must convey the return shape, and it does ('how many models each has'). For a zero-parameter read tool with readOnlyHint set, that is sufficient to call and interpret it correctly; only pagination/ordering behaviour is 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?

The tool takes zero parameters, which is the baseline-4 case. The description adds nothing parameter-related because there is nothing to add; it correctly focuses on the conceptual distinction instead.

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 ('Lists every provider in the catalogue') plus the payload ('how many models each has'), so the agent knows exactly what it gets. It also pre-empts the most likely confusion by defining what counts as a provider versus a sales channel, which is the differentiation that matters most among these siblings.

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 routes the agent away from this tool when it actually wants channel pricing, naming the alternative (`get_model_price` with a `channel`) and the condition that selects it. It does not address other plausible neighbours such as search_models or compare_models, so guidance is clear but not exhaustive.

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 readOnlyHint=true, the description adds rich behavioral context: it explains the step-function nature (only change points returned), handles multiple changes per day, and clarifies series labeling with qualifiers for collisions. This goes well beyond what annotations provide.

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 front-loaded with the core purpose and is mostly efficient, though the series labeling example adds some specificity that could be considered slightly verbose. Every sentence contributes to understanding the output.

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 no output schema and a read-only tool, the description is nearly complete—it covers return format, edge cases, and series labeling. However, it doesn't explicitly state if dates are inclusive (though the schema does) or how to interpret the price dimension labels beyond the collision example.

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 baseline is 3. The description adds meaning by explaining return format ('Each point is [date, amount]') and duplicate-date handling, but doesn't elaborate on the 'from'/'to' parameters beyond the schema's 'ISO date, inclusive'.

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 ('Returns') and resource ('a model's price over time'), making the purpose immediately clear and distinguishable from siblings like get_model_price.

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 implies usage for tracking price changes but doesn't explicitly say when to use this tool versus alternatives like get_model_price or compare_models. No when-not or alternative guidance is provided.

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 annotation already establishes this is a safe read. The description adds one genuine behavioral fact beyond the annotations: results are returned 'newest first'. It says nothing about pagination boundaries, whether the catalogue scope is workspace-wide, or volume of results, so the addition is modest.

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 that front-loads the verb and resource, lists the change categories, and ends with the ordering guarantee. No filler, nothing that could be cut without losing 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?

With no output schema, the description usefully enumerates what each record represents (increases, decreases, additions, removals) and the sort order. However, it leaves the days window and limit semantics unexplained, which matters for an agent that needs to control the query's time horizon and result size.

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% for both parameters; the schema gives types, defaults and bounds but no meaning. The description's 'recent' loosely gestures at the days window but never defines it, and the limit/pagination parameter is not addressed at all. It does not compensate for the coverage gap.

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 ('Lists') plus resource ('recent price changes across the catalogue') with an enumeration of the four change categories and their ordering. It is clearly distinguishable from price_history or get_model_price in substance, though it never names those siblings. Clear, but no explicit sibling differentiation.

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 word 'recent' weakly implies a time-bounded browsing use case, but there is no statement of when to prefer this over price_history or get_model_price, no exclusions, and no prerequisites. An agent must infer the choice entirely from the tool name.

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=false, so the description must carry the rest, and it does the most important part by warning that the call may be destructive and requiring user confirmation. It does not describe what the executed tool returns or how failures are surfaced, which is a real but minor gap for an arbitrary dispatcher.

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?

Four short sentences, each carrying a distinct rule: what it does, the lookup workflow, the preference for listed tools, and the destructive-action guard. The core purpose is front-loaded with no filler.

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

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

For an arbitrary-tool dispatcher with no output schema, the description covers invocation, discovery prerequisites, and the safety guard, which is most of what an agent needs. It stops short of noting that the return payload is whatever the invoked tool produces, leaving slight ambiguity about results.

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 'name' and 'arguments' are already documented in the schema; per the rubric, 3 is the baseline. The description reinforces the workflow ('by name') but adds no syntax, formatting, or nesting detail beyond what the schema provides for the nested arguments object.

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 ('Executes a tool by name with the given arguments') and immediately frames itself as a dispatcher for tools not directly listed. This makes it clearly distinguishable from siblings like find_tools and tool_schema, which are discovery/inspection tools rather than executors.

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 routing rules: use for tools not directly listed, look them up with find_tools, check arguments with tool_schema first, and prefer a directly-listed tool when one fits. It also adds a conditional guard ('if the action is destructive, ask the user to confirm'), which is a concrete when-to-act 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?

readOnlyHint=true already establishes the safety profile, so the description only needs to add context. It does add something meaningful — that results are decorated with a confidence level and backing sources — but says nothing about pagination, ordering, total result counts, or how the default limit of 20 behaves.

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 well-formed sentence with no filler, front-loading the action and resource before the return characteristics. Every clause 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?

With no output schema, the description is the only source of return-value information, and it covers that at a high level (prices, confidence, sources). It leaves out result ordering, truncation behavior, and how to handle a zero-match search — gaps that matter for a 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 coverage is 67%: query and provider are self-documenting, and limit carries bounds and a default even without prose. The description contributes no parameter-level detail (matching behavior, slug format, limit semantics), 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?

States a specific verb and resource ('Searches the catalogue of AI models') plus what comes back ('current prices, with a confidence level and the sources'). It does not distinguish itself from close siblings like get_model_price or compare_models, so an agent must infer the split between a catalogue search and a single-model lookup.

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 explicit when-to-use statement, no exclusions, and no named alternative. The description never tells the agent to prefer search_models over get_model_price for a known model, or when compare_models is the better call.

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 and idempotentHint, so the safety profile is covered and the bar is lower. The description still adds value by disclosing what the return contains (the full input schema plus required arguments), which is information annotations cannot convey; it omits only edge behavior such as what happens for an unknown tool name.

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, zero filler, with the capability statement front-loaded and the sequencing instruction second. 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?

With no output schema, the description carries the burden of explaining the return, and it does name what comes back. It is nearly complete for a trivial one-parameter read tool, missing only error/edge-case behavior for unresolvable tool names.

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?

There is one parameter with 100% schema description coverage, so the schema already defines 'name' as the exact tool name from find_tools. The description adds no syntax, format, or validation detail beyond that, 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: returns the full input schema of a single tool, and adds the useful detail that required arguments are included. It differentiates itself from siblings implicitly by naming find_tools and run_tool, though it never contrasts with a near-equivalent 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?

Gives explicit workflow placement: 'Call it after find_tools and before run_tool.' That tells the agent exactly when in the pipeline to invoke it, but offers no when-not-to-use condition or fallback for a name it cannot resolve.

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