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

Goes well beyond the annotations: annotations only say it's not read-only, is idempotent and open-world, while the description discloses the monetary cost, a 45-second wait, and error-recovery semantics (persist idempotency_key even on failures, reuse with the identical request to recover a lost response). It stops short of describing what a successful response contains beyond the key.

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?

Cost warning is front-loaded as the first token, followed by the gating condition, then latency, then recovery guidance, then the sibling routing. Six dense clauses, no filler, every sentence carries an operational constraint.

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 4-parameter paid mutation with no output schema, coverage is strong: cost, gating, latency, retry/idempotency and next-step routing are all present, and the nested input object is deferred to the referenced get_model schema. Missing only a description of the full success payload (e.g. the resulting job id/status) that the caller must act on.

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 75% and the schema already documents input, model and idempotency_key. The description still adds meaning the schema cannot: quote_id must come from quote for exactly the same model+input, and idempotency_key must be reused only with the exact same request. It doesn't add format detail for quote_id itself, which the schema leaves bare.

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?

Names the specific role precisely: the only tool that spends the user's Raywake balance, invoked with model+input+quote_id and producing a generation job. It is explicitly differentiated from the free siblings (quote produces the quote_id, get_job continues existing jobs) so an agent can place it in the workflow without opening any schema.

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

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

Gives a hard precondition (only after the user approves the quoted USD price), the exact provenance of quote_id, and matching constraint (same model+input). It also states the negative case: never start a new generation to continue a job — use free get_job instead.

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, non-destructive and openWorld, so the safety profile is largely covered. The description adds one genuinely new behavioral fact — the call is free — but says nothing about return shape, rate limits or what happens with an unfunded/debt wallet.

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 core action front-loaded and the upsell URL demoted to the end.

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

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

For a parameterless read with rich annotations and no output schema, the description covers what is returned and the currency. It stops just short of describing the response envelope or error cases, but nothing essential for correct invocation 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 there is nothing for the description to disambiguate; baseline 4 applies. Nothing in the schema is left unexplained.

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 ('Read ... wallet balances') plus the exact data returned (available, reserved, debt) and the unit (USD). This is unambiguous and cannot be confused with any sibling such as search_models or generate.

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?

Implies the when: use it to inspect balances, and it explicitly redirects the write-side intent elsewhere ('To add balance, top up at ...'). No explicit when-not condition, but the read-only scope is clear from the phrasing and annotations.

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 read-only, idempotent, non-destructive behavior, yet the description still adds real value: it is free, does not incur billing, waits up to 45 seconds, and that review states are terminal. It omits what happens if the wait expires before completion, which would be the last piece an agent needs.

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 key constraint ('Free') front-loaded and zero repetition of schema data. Slightly clipped phrasing ('Free.' as a fragment) but 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?

For a read-only polling tool with no output schema, it covers the essentials: no cost, no side effects, wait semantics, and terminal-state behavior. Missing only the timeout-expiry behavior and how to interpret a still-running result.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It explains `wait_seconds` semantically ('optionally waiting up to 45 seconds'), but says nothing about `job_id` (format, where to obtain it, length constraints), leaving one of two parameters undocumented.

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 ('Read an existing job and its outputs') and immediately distinguishes itself from the sibling `generate` by declaring it 'Does not start or bill a new generation'. An agent can tell exactly which tool performs retrieval.

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?

Clearly implies when to use it (polling an existing job) and warns against misuse ('do not resubmit' when review states are terminal). It does not explicitly name `generate` as the alternative for new work, so routing guidance is inferential rather than prescriptive.

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, openWorld and non-destructive, so the safety profile is covered. The description adds genuinely new traits: the call is free, pricing returned is only 'indicative', and media must be public URLs because local upload is unsupported. It stops short of describing the shape or size of the returned schema, but for a read-only lookup that is a minor gap.

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, front-loaded with the free-cost fact and immediately followed by the purpose. Every sentence carries information, though 'Free.' as a standalone fragment reads as a bullet-list artifact rather than smoothly integrated framing.

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

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

For a one-parameter read-only tool with full annotation coverage and no output schema, the description covers purpose, cost, input-sourcing rules, and the media constraint. The only meaningful omission is where the endpoint_id comes from and what the response actually contains, both of which an agent could reasonably want.

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 fully documented in the schema, including its link to search_models/get_model. The description adds no format, casing, or sourcing detail beyond that, so the baseline of 3 applies rather than any uplift.

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 two things returned: the model's input schema and an indicative starting price in USD. That is far more informative than the name 'get_model'. It does not name or contrast with search_models (which supplies the endpoint_id this tool requires), so sibling differentiation is left implicit.

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?

'Never invent inputs' and 'use public HTTPS URLs for media; local file upload is unavailable' are real invocation constraints that steer behavior. However, there is no explicit guidance on when to use this versus search_models for discovery or quote for pricing, which is the main decision an agent faces among these siblings.

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, non-destructive, closed-world. The description adds genuine context beyond them: it costs nothing ('Free'), and it discloses content scope (USD prices, public media URLs). It stops short of describing the exact return structure, but that is a minor gap.

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?

Short and front-loaded with the 'Free' cue, then a compact enumeration of the workflow. The parenthetical step list is dense but each item 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?

For a no-param, no-output-schema documentation tool, the description gives enough about what it covers and its cost to call it confidently. A line on the response shape would fully close the gap.

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

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

Zero parameters and 100% schema coverage, so there is nothing for the description to compensate for. Baseline 4 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 action and resource: reading the 'short Raywake workflow' that enumerates the pipeline (search, schema, quote, approval, generate, polling). This is clearly distinct from the sibling action tools, though it doesn't explicitly contrast itself with them.

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

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

'Read the short Raywake workflow' implies you call it to understand the process, and 'Free' hints at why you'd start here. But there's no explicit when-to-use/when-not or reference to alternatives like get_account or quote.

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, non-destructive and openWorld, so the safety profile is covered. The description adds one genuinely non-schema piece of context, "Free" (no credit cost), which is valuable for planning multi-call workflows; however it says nothing about return shape or whether the list is exhaustive or paginated.

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?

Nine words, zero waste. The cost note and the resource statement are both front-loaded and no filler sentences dilute the definition.

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-param read-only lookup with annotations covering safety and idempotency, this is nearly complete. The only gap is the absence of any hint about the returned category values (count, format, or whether they map 1:1 to search_models filters), which matters slightly more given there is no output schema.

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

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

The tool takes zero parameters, so the baseline of 4 applies. The description correctly signals a parameterless call by saying nothing about inputs, and the empty schema confirms it.

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+resource ("List the available model categories") tied to the sibling that consumes them (search_models), so the agent can tell it apart from get_model or get_playbook. It stops short of defining what a category is relative to model records, but the core purpose is unmistakable.

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?

"for search_models" implies the discovery pattern: call this first to learn valid category values before searching. There is no explicit when-not guidance and no stated alternative, so the usage is implied rather than spelled out.

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, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds genuinely new context: that the call is free (no cost) and that results are ordered newest-first. It omits pagination behavior and the meaning of the status filter, which would have been useful.

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 behavioral facts ('Free', newest-first) front-loaded before the follow-up routing advice. 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 does well to say results are newest-first and to point at get_job for detail. However, for a paginated list tool with three entirely undocumented parameters, it leaves the agent without guidance on paging or filtering, which is the main gap.

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 carries the burden for limit, offset, and status — and it addresses none of them. It never mentions that status filters results, that limit defaults to 20 and caps at 500, or what the offset does. An agent must infer all of this from bare property names.

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

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

States a specific verb and resource ('List recent jobs for this account') plus a scoping detail ('newest first'). It also distinguishes itself from get_job by naming that sibling as the follow-up step, though it does not differentiate from list_categories or the other list-style 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?

Gives a clear use case: recover an existing job_id, then continue with get_job. That is an explicit alternative-and-next-step pointer. It stops short of saying when *not* to use it (e.g., when you already have the job_id, skip straight to get_job).

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, idempotentHint=false, destructiveHint=false, openWorldHint=true; the description adds genuinely non-obvious behavior: it is free, does not spend balance, the price is time-limited, and a usage-based maximum reservation may apply. It does not clarify whether the reservation actually holds funds or how long the expiry window is.

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, front-loaded with the cost fact ('Free.') an agent needs first. The approval instruction is compressed into a slightly dense clause but nothing 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?

With no output schema, the description usefully names what comes back (price, expiry, usage-based maximum reservation) and the required human-approval gate. Remaining gap is the reservation semantics and whether the quote holds funds, which matters for a non-readOnly tool with openWorldHint=true.

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 spells out 'exact endpoint_id returned by search_models/get_model' and the provider-native input object. The description's 'exact model+input' only reinforces that constraint without adding format, size, or media-reference guidance 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?

States a specific verb+resource: get a time-limited USD price for an exact model+input. It also implicitly distinguishes itself from the sibling 'generate' by naming it as the downstream step, so an agent can tell pricing from execution 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?

Clearly sets the workflow context: call this before generate, show the user the price/expiry/reservation, and get approval. There are no explicit exclusions (e.g. when a cached or existing quote should be reused instead of re-quoting), which keeps it just short of a 5.

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

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

Annotations already cover read-only, idempotent and non-destructive, so the bar is lower, yet the description adds real context: the tool is free, prices are 'indicative starting prices' rather than quotes, and modality filtering happens locally before pagination. That last point is a non-obvious behavioral trait an agent would otherwise have to discover empirically.

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, front-loaded with the verb and cost signal, with no filler. The telegraphic style ('Use get_model before quote') is slightly ambiguous but earns its brevity.

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

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

With no output schema, the description should say more about the shape of results; it only mentions indicative prices. It is adequate for a discovery call but leaves result fields, pagination limits and empty-result behavior unstated.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It only clarifies modality's local-filtering behavior and its interaction with pagination; query, category and page are left entirely undocumented, and it's unclear whether category is exact-match or full-text.

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 ('Search Raywake AI models') and what comes back (indicative starting prices in USD). It signals the search-vs-detail split with get_model, though it doesn't explicitly distinguish itself from list_categories.

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 get_model before quote' establishes a workflow around the tool, implying search is the discovery step and get_model the detail step. However, there is no explicit statement of when to prefer this over list_categories or when not to use it, so guidance is 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.