Agent Data Tools: AI text and media

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

Annotations already cover the write/open-world/non-idempotent profile, and the description adds genuinely new behavioral context not in structured data: the exact per-call cost ($0.002 USDC), the payment rail (x402 on Base), and the token ceiling. It does not cover latency or failure/refund behavior, which keeps it from 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?

Two sentences, zero filler: the first front-loads purpose, model, and limits, the second carries usage and cost. Nothing redundant and it is well ordered for an agent scanning for a quick decision.

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 still conveys what comes back (a text answer) and the key constraints an agent needs before invoking: model, token cap, temperature, and the fact that payment is required. It is complete enough to call correctly, though it omits any failure/timeout expectation.

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 every parameter (prompt, system, maxTokens, temperature) is already documented in the schema. The description restates the token cap and optional system prompt but adds no syntax, format, or interaction semantics beyond it, 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?

The description gives a concrete verb+resource (send a prompt, get an answer) and even names the backing model (Llama 3.1 8B Instruct) with its output-token cap. It implies generic usage versus specialized siblings (ai_classify, ai_sentiment, ai_rewrite) through its open-ended use cases, but never names a sibling to route against, so it lands just short of a 5.

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 states when to use it: drafting, reasoning steps, Q&A, and 'any quick LLM call without an AI provider account.' That is clear context, but there is no when-not guidance or explicit routing to the many specialized ai_* siblings, so it stops at 4.

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 cover the safety profile (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false), and the description adds a genuinely new trait: a paid call costing $0.002 USDC on Base via x402. That cost/auth mechanism is not derivable from annotations or schema. It doesn't disclose latency or retry/refund behavior, keeping it below 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 tight sentences: capability first, then use cases, then cost. Every sentence carries distinct information with zero padding.

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 compensates by describing the return shape (label, reason, ranking). Paid-call mechanics and input constraints are covered, so an agent has enough 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 coverage is 100%, meaning both 'text' (8,000 char limit) and 'labels' (2-20) are already documented in the schema. The description's restatement of the 2-20 label constraint adds nothing new, 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?

The description opens with a precise verb and method ('Zero-shot classification'), names the inputs, and states the outputs ('best label, a short reason and a ranking'). This clearly separates it from adjacent AI siblings like ai_sentiment or ai_extract-json.

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 gives concrete when-to-use contexts ('routing tickets, tagging content, intent detection and moderation queues'), which is more than most siblings offer. It stops short of naming alternatives or exclusions, so it's clear but not fully routing.

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 safety (destructiveHint=false, openWorldHint=true), so the bar is lower; the description adds the materially important fact that each successful call costs $0.002 in USDC on Base via x402. That billing/authorization detail is exactly the kind of context structured fields cannot convey, and it also explains why readOnlyHint is false for a pure computation tool. It does not discuss rate limits or failure/refund behavior, keeping it below 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 compact sentences with no filler: capability first, then use cases, then cost. The cost constraint is placed last where it belongs and no sentence restates another.

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 tool with no output schema, the description supplies the return shape (1024 dims), model provenance, language coverage, intended use cases, and payment terms. Nothing an agent needs to invoke it 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?

With one parameter at 100% schema description coverage, the schema already documents the 'text' input and its 4,000-character limit, so the baseline is 3. The description adds only marginal meaning beyond it, mainly that 100+ languages are supported via BGE-M3, which slightly informs acceptable input but does not go beyond confirming the schema constraints.

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 the exact output (a 1,024-dimension embedding vector), the underlying model (BAAI BGE-M3), and the input shape (up to 4,000 characters), which is a specific verb+resource statement. It is immediately distinguishable from siblings like ai_classify or ai_sentiment that also accept text but return labels rather than vectors.

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 enumerates intended applications – semantic search, RAG retrieval, clustering, deduplication – which gives the agent clear selection context. It stops short of naming when to prefer a different sibling (e.g. ai_classify for labeling) or any exclusions, so it is clear context without 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 cover the safety profile, and the description adds genuinely non-obvious context: the $0.002 USDC-on-Base cost, the x402 payment mechanism, and that missing fields come back as null. This explains why readOnlyHint=false (it is a paid call, not a free read). It does not mention rate limits or failure/refund behavior, keeping it out of 5 territory.

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 compact sentences, front-loaded with what the tool does and its output, then usage, then cost. No filler. Slightly more could be trimmed, but every sentence carries 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 correctly explains the return value (a JSON object with nulls for absent fields). Inputs are covered by the schema and payment by the description. Only error/edge behavior is left implicit, which is minor for a simple extraction 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 both parameters (text with its 12,000-char limit, fields with its 1-30 comma-separated constraint) are already fully documented. The description adds no syntax or format detail beyond the schema, which is the baseline-3 case.

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 (pull/extract) and resource (named fields from unstructured text) plus the output shape (JSON object with nulls). The examples (emails, invoices, listings, bios) make the resource concrete. It does not explicitly differentiate from lookalike siblings such as `extract` and `text_extract`, so it stops short of a 5.

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 to turn messy text into structured data for an agent" gives a clear context for when to reach for it, and the examples reinforce that. There is no when-not guidance and no named alternative among the many `ai_*`/`extract*` siblings, so it is context without exclusions.

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

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

The description goes beyond the annotations by disclosing the paid nature of the call: $0.002 in USDC on Base per successful call via x402, and notably only charges on success. This is meaningful behavioral context that complements the readOnlyHint=false annotation rather than contradicting it. It omits error handling and return-shape detail, but the cost/auth disclosure is substantial.

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: what it returns, where to use it, and what it costs. The output contract is front-loaded and 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?

For a two-parameter, no-output-schema tool, the description covers the essentials: output semantics (ordered keywords), usage contexts, and cost. Minor gaps remain around failure behavior and rate limits, but an agent has enough 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 100%, with both the text length cap (12,000 chars) and the count range (3-30, default 10) documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 is correct.

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 the specific resource (keywords and key phrases) and its ordering (most relevant first), which is a concrete output contract. The four listed use cases (tagging, SEO, search indexing, topic detection) further separate it from siblings like ai_summarize-text, ai_classify, and ai_extract-json.

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 clearly states when to reach for it via the four application scenarios, giving an agent enough context to route between it and adjacent AI tools. It stops short of naming an alternative or stating when not to use it, so it is not fully explicit.

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 cover safety (destructive=false, readOnly=false, openWorld=true), and the description adds genuinely useful non-annotation context: a per-call price of $0.002 in USDC on Base via x402, and that the charge applies only on success. It does not mention non-idempotency or any rate/length failure behavior beyond the schema's character cap.

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, no filler: output shape first, then intended use cases, then cost. Every sentence carries distinct information and the most decision-relevant content is front-loaded.

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?

No output schema exists, and the description compensates by describing the return format as a Markdown outline with headings and bullets. Together with cost disclosure and full schema coverage, an agent has what it needs to call it, though error/latency behavior is 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 100% — the schema already documents 'text' (text or topic, up to 12,000 chars) and 'depth' (heading levels 1-3, default 2). The description adds no syntax, format, or interplay 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 artifact: produces a structured Markdown outline (headings and bullet points) from either supplied text or a topic. The output format is named, and the 'text or topic' dual input mode makes it readily distinguishable from siblings like ai_summarize-text or ai_rewrite.

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 concrete usage contexts ('plan articles, reports, talks and documentation'), which is clear positive guidance. It stops short of naming alternatives or exclusions (e.g. when to prefer ai_summarize-text for condensing rather than structuring), so it does not reach the 5 bar.

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 declare the safety profile (readOnlyHint=false, idempotentHint=false, openWorldHint=true, destructiveHint=false), so the description's added value is the payment disclosure: $0.002 USDC on Base per successful call via x402. That auth/cost detail is genuinely non-obvious and material before invoking. It omits rate limits or whether input text is retained.

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 core action and styles before the usage and cost details. The style enumeration is somewhat redundant with the enum but is 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?

For a simple two-parameter text tool with no output schema, the description covers action, styles, use cases and cost, which is close to sufficient. It never indicates what is returned (rewritten text only?) or whether the original is preserved, leaving a small gap that an output schema would otherwise fill.

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 both parameters are documented in the schema, including the default of 'professional'. The description merely re-lists the same style values as the enum, adding no syntax, length, or interaction guidance beyond structured data.

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 (rewrite) plus the full set of target styles, and the phrase 'keeping the meaning and language' implicitly separates it from siblings like ai_summarize-text or ai_translate. It is clear on its own, though it never names an alternative tool 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?

Gives concrete usage contexts ('polish emails, replies, product copy and messages'), which tells the agent when this tool fits. It stops short of exclusions or naming when to prefer a sibling (e.g., ai_summarize-text for shortening).

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 cover only the safety profile (readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false), so the description carries the interesting burden and does: it discloses that calls are paid, in USDC on Base, at $0.002 per successful call via x402. That is exactly the auth/payment context an agent must know before invoking, and it also explains why a pure inference call is flagged non-readonly.

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: what it does first, then when to use it, then cost. No filler, no repetition of the parameter block, and the most decision-relevant facts are front-loaded.

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-param tool with no output schema, the description does describe the return shape (label plus confidence score), the model, and the payment model, so an agent has what it needs to call it. The only real gap is failure behavior — what happens if payment fails or the text exceeds the limit — which is left implicit.

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?

Only one parameter and schema description coverage is 100%, with the schema already stating 'English text, up to 4,000 characters'. The description's mention of 'English text' echoes rather than extends the schema, so the baseline 3 for fully-documented params 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-ish task and resource (positive/negative sentiment of English text, with a confidence score) plus the exact model and training set (DistilBERT fine-tuned on SST-2). This cleanly separates it from generic siblings like ai_classify or ai_extract-json 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 concrete usage context — 'triage reviews, support messages, social posts and replies' — which tells the agent when this tool fits. However, it never excludes anything or names an alternative (e.g. ai_classify or ai_chat) for cases where sentiment alone is insufficient.

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 declare the safety profile (not read-only, open-world, not idempotent, not destructive), so the description's job is to add context — and it does: per-call cost of $0.003 USDC on Base via x402, plus the return shape (base64 audio with content type). Pricing and payment mechanism are exactly the kind of operational detail annotations cannot convey.

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 compact sentences, front-loaded with capability, then use cases, then cost/payment. Every clause carries information (limit, languages, engine, return format, price, chain, payment protocol); a touch dense but no waste.

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?

No output schema exists, and the description compensates by stating the return format (base64 plus content type). It also covers input limits, language options, engine, and the monetary cost of invocation. An agent has everything needed to call this correctly and anticipate the charge.

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 description largely restates the schema (1,000-character limit, the six supported languages). It adds the output encoding detail (base64 with content type), which is useful but not a parameter-level clarification. Baseline 3 applies when the schema does the heavy lifting.

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 (turn text into speech), the resource (audio file), the input limit (1,000 characters), and the engine (MeloTTS). It is unmistakably distinct from directionally opposite siblings like transcribe and from the many ai_* text 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?

Names concrete use cases (voice replies, audio notes, accessibility, phone/chat bots), which gives the agent a clear context for selection. It stops short of explicit exclusions or naming an alternative (e.g. transcribe for the reverse direction), so it is clear context without routing.

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 (readOnlyHint=false, destructiveHint=false, openWorldHint=true, idempotentHint=false) cover the safety profile, and the description adds material context beyond them: a per-call cost of $0.002 USDC on Base charged per successful call via x402, plus the character ceiling and output format. It does not describe failure/retry behavior or what happens on an over-limit input, which is the remaining 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?

Two sentences, front-loaded with purpose and scope, then usage with the alternative, then the cost caveat. Every clause carries information; no filler or repetition of the 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?

No output schema exists, and the description compensates by stating the return shape (sentences plus bullet key points). It covers purpose, scope limit, routing to the sibling, and the payment model, which is everything an agent needs before calling.

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 both parameters (text and sentences) are already documented in the schema; the baseline is 3. The description restates the 12,000-character limit but adds nothing about the 'sentences' length control (1-8, default 3) beyond what the schema already says.

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 (summarize) plus resource (text) with an explicit scope limit of 12,000 characters and a stated output shape (a few sentences plus bullet key points). It also distinguishes itself from the near-identical sibling 'summarize' by naming it as the URL-based alternative.

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 when to use it ('long emails, documents, transcripts and tool outputs') and when to route elsewhere ('for a web page by URL, use /summarize'), naming the alternative directly. Nothing about tool selection is left to inference.

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

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

Annotations cover the safety profile (readOnlyHint=false, openWorldHint=true, non-idempotent, non-destructive). The description adds genuinely new behavioral context beyond them: the per-call cost ($0.002 USDC on Base) and the x402 payment mechanism, which matters for invoking 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?

Three sentences, front-loaded with the core action, then parameter guidance, then usage and cost. No filler, though the language-code list is somewhat verbose.

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?

No output schema exists, but the description sufficiently covers inputs, usage, model, and cost. Return format is unstated, which is a minor gap for a translate tool but not critical.

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 goes slightly beyond it by expanding the ISO-code examples (en, sv, de, fr, es, zh, ja) and restating that source is optional with default en, adding marginal clarity.

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 (translate) and resource (text) plus the exact model (Meta's M2M100 1.2B), which clearly distinguishes it from the many other ai_* siblings like ai_rewrite or ai_summarize-text.

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 an explicit use case ('Use to localise messages and documents'), which helps an agent pick it over generic ai_chat. It stops short of naming when-not-to-use or an alternative tool, so it doesn't reach 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?

Beyond the annotations, the description discloses the cost ($0.01 USDC on Base per successful call, paid via x402), the public-URL requirement, and accepted formats/size. It does not cover failure/refund behavior or latency, but the payment detail is genuine context the structured fields do not 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?

Three sentences, front-loaded with the core function before constraints and cost. Dense but nearly every clause carries information; little waste.

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 return-value burden and does indicate the output is a detailed description including visible text, though it never states the response format (plain text string). It is otherwise complete for a two-parameter call, covering payment and input constraints.

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 both url and question, including the max-300-character limit and default behavior. The description adds the description-vs-question mode framing and 'including any visible text,' but mostly restates the schema, so the baseline 3 holds.

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: a vision model returning a detailed description of an image at a public URL, or answering a question about it. It does not explicitly name or contrast itself with nearby siblings like image, screenshot, or extract, leaving that differentiation to inference.

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 gives concrete when-to-use cases: 'alt text, OCR-style reading of screenshots, chart reading and content checks.' There are no stated exclusions or named alternatives, so the agent must still infer when another sibling is preferable.

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?

Goes well beyond the annotations (which only flag non-read-only, open-world, non-idempotent, non-destructive) by disclosing output format and encoding, latency ('a few seconds'), the steps/speed tradeoff, and the payment model ('$0.02 in USDC on Base per successful call, paid with x402'). The billing/auth requirement is exactly the kind of context an agent needs before invoking.

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 dense sentences, front-loaded with the core action and model, then output, use cases, parameter tradeoff, and cost. Every sentence carries unique information 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?

With no output schema, the description compensates fully by describing the return type (base64 JPEG at 1024x1024), latency, and cost/payment mechanism. An agent has everything needed to decide and call 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 coverage is 100%, so baseline is 3, but the description adds meaning beyond the schema: 'steps ... trades speed for detail' explains the quality/latency tradeoff that the schema's 'Diffusion steps, 1-8 (default 4)' does not. The prompt's role is also clarified via 'Send a prompt, get ... back'.

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 ('Text-to-image generation with FLUX.1 schnell') and specifies the exact model and output ('1024x1024 JPEG back as base64'). No sibling tool generates images, so the scope is unambiguous and immediately differentiable from screenshot/summarize/etc.

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 concrete when-to-use context: 'Use for illustrations, thumbnails, mockups, avatars and social media images.' It does not name exclusions or an alternative tool, but with no competing image-generation sibling there is little to exclude, so the guidance is clear and actionable.

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 declare openWorldHint and non-idempotent, so the network/side-effect profile is partly covered. The description adds material context the annotations do not: the 5 MB size cap, accepted formats, the returned fields, and the per-call cost of $0.02 in USDC on Base via x402. This is a paid, one-shot external call and the description makes that explicit.

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?

Five compact sentences, front-loaded with the core action and engine, then output shape, then accepted inputs, then use cases, then cost. The cost detail is slightly buried at the end 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?

There is no output schema, so the description correctly states what is returned (transcript text, detected language, duration, word count). For a one-parameter, read-only-adjacent but open-world paid call, this covers format, size, outputs and billing well.

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 single url parameter is fully described in the schema (100% coverage), including the max size and http(s) format. The description reinforces the URL requirement and adds the format examples (MP3, WAV, M4A, OGG) that the schema does not include, plus the size limit.

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 (Transcribe) and resource (speech from an audio file at a public URL) with the underlying engine (Whisper large-v3-turbo). Clearly distinguishable and no sibling overlap.

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?

Names concrete use cases (voice notes, podcast clips, meeting snippets, voice messages) and the accepted input formats with a 5 MB limit, giving clear context. It does not name or exclude alternates, but none of the siblings are close substitutes.

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