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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, but the description adds material context they do not carry: experimental status, the ADMIN-key-only auth constraint, exclusion of inference keys, and the refusal of x402 wallet auth. It also bounds the result to the last 50 events, which is behaviorally important.

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 it returns, then the caveats. Nothing is redundant and no sentence could be dropped without losing an auth or scope 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 parameterless read endpoint with no output schema, the description covers the essentials: what is returned, how many records, and every auth prerequisite. An agent has everything needed to decide whether it can call it.

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 no parameter semantics to explain; baseline is 4. The description's fixed 'last 50' scope correctly signals that no filtering or paging arguments exist.

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 precise verb+resource+scope: 'Get the last 50 exceeded rate-limit events for the account.' This is distinguishable from the sibling venice_api_key_rate_limits, which concerns current limits rather than a historical log of exceeded events.

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 clear operational context — experimental endpoint, ADMIN API key required, inference keys cannot call it, and no x402 wallet auth — which tells the agent whether it is even eligible to call it. It does not, however, explicitly name an alternative tool or a when-not-to-use condition relative to the rate-limits sibling.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered by structured data. The description adds a genuinely useful behavioral constraint — that x402 wallet auth is rejected and an API key is mandatory — but says nothing about rate-limit semantics, caching, or response freshness.

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

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

Two sentences with no filler, front-loading the returned data before the auth constraint. 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 and no parameters, the description carries the burden of describing the return payload, and it does so by listing the five fields returned. The auth requirement is also covered. It stops short of routing the agent away from the similar key/billing siblings, which is the only meaningful 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The schema is trivially empty and adds no competing information.

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 ('Get') and enumerates the exact resources returned: balances, access status, tier, expiration, and model-specific rate limits. It is distinguishable from most siblings, though it never explicitly contrasts itself with the closely named venice_get_api_key, venice_api_key_rate_limit_logs, or venice_billing_balance, which also touch key/billing data.

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

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

The description gives one actionable precondition ('API key required — this endpoint does not accept x402 wallet auth'), which tells the agent when this call will succeed. However, it names no alternative tool and gives no condition for choosing this over venice_get_api_key or venice_api_key_rate_limit_logs, so usage is only implied.

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 annotations, which only declare non-read-only, open-world, non-idempotent, non-destructive. The description discloses the 1 MiB upstream rejection and its memory rationale, page size (8000 chars, timestamp_limit default 200), in-memory per-session handles with a 10-minute / 16-result lifetime, exactly-once billing, and both x402 and API-key auth paths.

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-loaded with the core action, then layered into transport, limits, paging/handle semantics, and auth. Dense but every sentence carries required information; 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 a 9-parameter tool with no output schema, the description covers the hard parts: paging protocol, handle lifetime, billing semantics, and auth. Remaining gaps are return-value shape details and defaults for model/language/response_format, which are minor given the paging contract is explicit.

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

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

At 67% schema coverage the description adds real meaning for the paging parameters and the audio_url/result_handle interaction. However, model, language, and response_format have no description in either schema or prose, and the description does not compensate for those gaps.

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?

Opens with a specific verb+resource ("Transcribe audio") and immediately clarifies the transport (server-side URL fetch, multipart/form-data upload). This separates it from sibling venice_tts by direction, though it never names a sibling 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 solid operational when-to-use guidance: when result_handle is supplied, audio_url is ignored; later pages must be requested with the handle; an expired handle is an error rather than a silent re-transcription. It stops short of naming alternatives (e.g., venice_tts, venice_audio_quote) or when not to use it.

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 closed-world, so the safety profile is covered structurally. The description adds a genuinely useful behavioral fact not in the annotations — "No authentication required" — plus the pre-queue timing guarantee, though it says nothing about rate limits or quote validity windows.

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 core action and scope; each sentence contributes (purpose, use case, auth precondition) with no redundancy.

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

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

For a simple 3-param read-only quote tool with full schema coverage and annotations, this is nearly sufficient. The one minor gap is that no output schema exists and the description never indicates what the quote actually returns (e.g., cost amount, currency), leaving the agent to discover the response shape empirically.

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 model, character_count, and duration_seconds are all documented in the schema with their constraints. The description adds no parameter guidance beyond noting nothing about model-specific price dimensions, so baseline 3 applies.

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

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

States a specific verb (get a price quote), resource (music generation), and timing constraint (BEFORE queuing), which cleanly distinguishes it from the sibling venice_music_generate. An agent can tell immediately this is a pre-flight costing call, not a generation call.

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?

"BEFORE queuing" and "Useful for budgeting" give clear context for when to reach for this tool rather than the generator. No explicit when-not conditions or named alternatives (e.g., venice_video_quote for video), so it stops short of the top tier.

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

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

Annotations already cover read-only, idempotent, non-destructive semantics, so the description earns credit for adding auth-specific behavior: admin-key requirement and rejection of inference keys and x402 wallet auth. It omits return shape and any rate-limit or caching behavior, but adds real context beyond the annotations.

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

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

Three short sentences, purpose front-loaded, followed by the auth constraints that matter most. No filler or redundant restatement 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?

With no output schema, the description does carry the return-value burden and names the three credit dimensions returned. Auth and scope are fully covered; a minor gap is that it doesn't explain units, currency conversion, or whether bundled credits refresh.

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.

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 ('Get') plus resource ('billing balance') and the exact quantities returned (USD, DIEM, bundled-credit availability) scoped to the authenticated account. This distinguishes it cleanly from venice_x402_balance and venice_billing_usage_* 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?

Clearly states the prerequisite (ADMIN API key) and two explicit exclusions (inference keys cannot call it; x402 wallet auth is not accepted), which effectively routes callers toward venice_x402_balance. No alternative tool is named directly, so it stops short of a full when/when-not/alternatives triad.

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

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

Annotations already establish this as a safe, idempotent read, but the description adds genuinely new operational facts: a 10-minute cache window, an ADMIN-key requirement that inference keys cannot satisfy, and the exclusion of x402 wallet auth. Those are real behavioral traits an agent cannot derive from the schema or annotations.

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

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

Four short sentences, each carrying distinct information (purpose, caching, parameter rule, auth), with the core purpose front-loaded. Slightly bloated by the closing 'does not accept x402 wallet auth' clause, but nothing is wasted or 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 does a fair job sketching the response shape ('aggregated usage by date, model, and API key') and covers caching and auth constraints. It stops short of describing metrics returned (tokens, cost) or any pagination, which keeps it from being fully self-sufficient for an analytics endpoint.

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 the mutual exclusivity of lookback vs. start_date/end_date and the YYYY-MM-DD format are already documented in the schema. The description only restates the either/or rule, adding no format, default, or boundary detail beyond it. 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?

It names a specific verb (get) and resource (aggregated usage) and scopes it to date/model/API key dimensions, so the agent knows exactly what comes back. However, it never differentiates from the closely named sibling venice_billing_usage_history, leaving the agent to guess which billing usage tool to pick.

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 a clear selection rule for parameters ('Choose either lookback or a complete start/end date range') and states the access condition (ADMIN key). But it offers no guidance on when to prefer this tool over venice_billing_usage_history or venice_billing_balance, which is the main routing decision an agent faces here.

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 cover read-only/idempotent safety) by disclosing the 64 KiB page-failure mode with no partial rows or next cursor, the cursor-format coupling, ascending ordering, and the ADMIN-key vs inference-key and x402 auth restrictions. These are exactly the behavioral traits an agent cannot infer from structured fields.

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-loaded with the core purpose and pagination model, then layered constraints, with no filler sentences. It is dense and mostly non-redundant, though a couple of points (default 10 rows, cursor/format coupling) restate what the schema already says.

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 paginated billing tool with no output schema, it covers pagination mechanics, failure behavior, auth requirements, and continuation semantics thoroughly. An agent has everything needed to call it correctly across first-page and continuation scenarios.

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 already 83%, so the schema carries most parameter meaning. The description still adds value by explaining that cursor continuation drops filters and that CSV cursors persist format=csv, which clarifies how cursor interacts with the other parameters beyond the schema 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 (walk) and resource (billing usage) plus ordering (ascending timestamp) and mechanism (cursor pagination), which is precise enough to act on. It does not, however, explicitly distinguish itself from the sibling venice_billing_usage_analytics, so the differentiation is implied rather than named.

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 strong operational guidance: cursor continuation must omit original filters, CSV cursors encode format=csv, and the endpoint is explicitly not the deprecated /billing/usage. It also states the ADMIN key requirement and that x402 wallet auth is unsupported, which routes the caller correctly, though it never names the analytics sibling as the alternative for aggregated data.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds genuinely non-redundant context: the endpoint requires an API key and rejects x402 wallet auth, which matters because the sibling set has an entire x402 family. It still omits result ordering and page-size defaults.

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, with the action and scope front-loaded and the auth caveat second. Nothing could be removed 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?

For a read-only listing tool with no output schema and no nested objects, the description covers auth and pagination but leaves return structure and ordering unexplained. With only one of three parameters documented in the schema, the definition is adequate but not self-sufficient.

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

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

Schema description coverage is only 33% — slug is documented with an example, but page and pageSize have no descriptions at all. The description's word 'paginated' gestures at those two parameters without explaining defaults, maximum page size (100), or how pagination terminates, so 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?

States a specific verb and resource — 'List paginated public reviews for a Venice character' — which is unambiguous and clearly distinct from venice_get_character or venice_chat_with_character. It does not explicitly name a sibling alternative, 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?

The second sentence is an authentication constraint (API key, not x402), not guidance on when to choose this tool over the character-related siblings. An agent gets no signal about when to fetch reviews versus character details or chat.

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 far beyond the annotations (readOnlyHint=false, openWorldHint=true, idempotentHint=false): non-streaming plaintext output, hard truncation at 8000 chars with omitted_chars reporting, completion id and resolved model in structured content, a TEE signature JSON block for X-Venice-TEE responses, explicit rejection of enable_e2ee, and both x402 wallet and API-key auth paths. This is exactly the behavioral context an agent needs before calling.

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?

Tight, telegraphic sentences with zero filler; every clause carries a distinct fact (streaming mode, truncation, structured content, TEE, auth). Slightly list-like rather than organized by invocation order, 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?

For an 18-parameter, nested-schema tool with no output schema, the description covers the operationally risky edges: truncation limits, what appears in structured content, and auth modes. Gaps remain around model selection policy and tool-calling/structured-output semantics, but the essentials an agent needs to avoid surprises are present.

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 18 parameters and only 39% schema description coverage, the description is expected to compensate, but it only touches truncation length and the rejected enable_e2ee flag. It says nothing about temperature, top_p, tools/tool_choice, response_format, reasoning, prompt caching, or venice_parameters, leaving half the surface documented only by 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 — 'Run an OpenAI-compatible chat completion via Venice's text-model catalog' — which clearly separates it from image, video, TTS, and embedding siblings. It does not differentiate itself from the close siblings venice_responses or venice_chat_with_character, even though the schema points at venice_list_characters for characters.

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?

Implied usage is clear (general text generation), and it adds two useful conditions: uncensored prompts allowed, and enable_e2ee is rejected. However, it never says when to prefer venice_responses or venice_chat_with_character over this plain chat endpoint, leaving the most likely sibling confusion unresolved.

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 three non-obvious traits: completion id and actual model surface in structured content, TEE-marked responses carry an extra JSON block for venice_tee_signature, and the auth asymmetry where character lookup is API-key-only while completion supports x402. The NSFW policy statement adds a further content-boundary caveat that annotations cannot express. Nothing here contradicts readOnlyHint=false or openWorldHint=true.

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?

Purpose leads, then the response-shape note, then the auth caveat, then the content policy — a sensible order with no filler sentences. The middle sentences are dense and slightly run-on, packing structured content, TEE blocks, and x402 into two compressed clauses.

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

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

The description compensates well for the missing output schema by explaining what structured content and the TEE text block contain. However, for a five-parameter chat tool with zero schema descriptions and no output schema, the input side remains thin — no guidance on messages shape, token limits, or model override — leaving real gaps for an agent composing a call.

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% across all five parameters, so the description must carry the burden and it largely does not. It only gestures at character_slug ('by slug'); model, messages, max_tokens, and temperature get no meaning at all — notably it never says whether the model parameter overrides the character's default model, which is exactly the ambiguity the structured-content note raises.

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 first sentence gives a specific verb and resource ('Chat with a Venice character by slug'), which clearly separates it from the generic venice_chat and from lookup tools like venice_get_character. It stops short of naming the sibling it replaces, so the differentiation is inferred from the resource rather than stated.

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 context is present but indirect: the x402 note explains that users paying via x402 must fetch character info with an API key first, and the 'Uncensored' line signals the content policy. There is no explicit statement of when to pick this over venice_chat or venice_responses, so the routing is implied rather than prescribed.

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?

Adds 'No authentication required' and characterizes the list as 'live, authoritative,' which goes beyond the readOnly/idempotent/non-destructive annotations by signalling dynamic, current data rather than a static enum. It does not describe the return shape or count, but with no output schema and full annotation coverage the bar is lower.

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

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

Two short sentences, front-loaded with the core action and resource, then the auth constraint. No filler; every clause 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?

For a zero-param, no-auth list tool whose safety profile is fully covered by annotations, the description is essentially complete: it conveys what is returned (network slugs) and the calling constraint (no auth). Minor room to state the return format explicitly, but nothing essential 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 baseline is 4. There is nothing for the description to clarify beyond what the empty schema already implies.

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 ('List') and resource ('network slugs'), plus the scoping detail that these are the slugs accepted by venice_crypto_rpc. This cleanly distinguishes it from the sibling venice_crypto_rpc, which consumes rather than produces this list.

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?

Naming venice_crypto_rpc as the consumer implicitly tells the agent this is the discovery call to make before invoking the RPC tool. There is no explicit when/when-not or rival alternative named, but the workflow relationship is clear.

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

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

Goes well past the annotations (destructive/openWorld/not-idempotent) by disclosing the 64 KiB rejection threshold and that Venice bills rejected oversized responses, the two auth modes (x402 wallet, no account needed, or API key), the 100-item batch cap, and the single-request rule for transaction relays. These are exactly the failure modes an agent would otherwise hit blind.

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 sentences, each carrying distinct information (routing, call forms, relay rule, size/billing limit, auth), with the core purpose front-loaded. No filler or restated schema text.

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?

Although there is no output schema, the description covers the response shape ('compact JSON') and the size ceiling, plus auth, batching, and idempotency requirements. Nothing an agent needs to invoke this proxy safely and 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?

Schema coverage is 100%, so the schema already documents every parameter, but the description adds the relational semantics the schema can't convey: the two mutually exclusive call forms, the network slug coming from venice_crypto_networks, and the retry contract for idempotency_key. That is meaningful added meaning above the baseline 3.

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 ('Proxy one JSON-RPC request or a batch of up to 100 requests to a supported blockchain network') and explicitly distinguishes itself from the sibling venice_crypto_networks. An agent can immediately tell this is the execution tool versus the network-listing 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 routing: use venice_crypto_networks for the live network list; use rpc_method/rpc_params for a simple call versus request for custom IDs or batches; relays must be single (not batched) with an idempotency_key, reused on retry. Conditions and alternatives are stated, not inferred.

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 a non-read-only, non-idempotent profile but say nothing useful about auth or limits, so the description carries real weight here: it discloses two supported auth paths (x402 wallet, no Venice account required, or API key) and that oversized batches are rejected before submission. It does not explain the return payload or how encoding_format changes output, 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 tight sentences, front-loaded with the operation before the batching rule and auth detail; nothing is wasted. Minor redundancy where the 128 limit restates the schema rather than adding to it.

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 three-parameter tool with no output schema, the definition covers input limits and auth but leaves the response side entirely unspecified — no mention of vector dimensionality, ordering, or what base64 encoding returns. The 'OpenAI-compatible' note partially compensates, but an agent still has to infer return structure.

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%, so the baseline is 3. The description's 128-item ceiling duplicates what the schema already encodes in maxItems and the input description, and it never addresses the undocumented encoding_format enum or what 'model' identifiers are valid, so it adds little 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 and resource ('Compute embeddings for text input') and adds a disambiguating qualifier ('OpenAI-compatible') that tells an agent exactly what shape of operation and payload to expect. No sibling in the list does embeddings, so no differentiation is needed.

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

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

The description gives an operational usage rule — max 128 texts per call, split larger jobs into separate batches — but never states when to choose this tool over alternatives (e.g. retrieval-style embeddings vs. chat) or what prerequisites/model selection look like. Usage is implied by the batching constraint rather than explicitly framed.

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 behavior, so the bar is lower. The description still adds valuable context beyond them: the response does not reveal the full key secret, ADMIN auth is required, and x402 auth is rejected — all non-obvious operational facts.

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 the resource and return contents before the auth caveats. No wasted words; each sentence carries distinct 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?

For a read-only single-key lookup, the description covers scope, returned data types, secret non-disclosure, and auth requirements. With annotations covering the safety profile and schema covering the parameter, this is nearly complete; only explicit alternative routing 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 single 'id' param is fully documented as 'API-key ID, not the key secret.' The description restates this same distinction rather than adding new meaning, so 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 (Get) and resource (metadata, usage, balances, rate-limit details) scoped to one API-key ID. The singular 'one API-key ID' clearly distinguishes it from the sibling venice_list_api_keys, and the enumeration of returned data types makes the purpose unambiguous.

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

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

Gives clear usage context via auth constraints: ADMIN API key required, inference keys cannot call it, and x402 wallet auth is not accepted. It does not explicitly name alternatives (e.g., 'use venice_list_api_keys to enumerate all keys'), so routing is implied by the singular scope rather than stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world behavior, so the safety profile is covered. The description adds meaningful context the annotations cannot: the endpoint requires an API key and explicitly rejects x402 wallet auth, which prevents a real failure mode at call time.

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

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

Two short sentences, front-loaded with the core action and followed immediately by the auth constraint. No filler and nothing that could be trimmed 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?

For a single-parameter read tool with full schema coverage and complete annotations, this is nearly sufficient: what it returns (public character fields) and error behavior on a bad slug are the only gaps, and the auth caveat is the highest-value addition already present.

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 slug property already carries a format pattern and an example ('alan-watts'). The description adds only the phrase 'by slug', which restates the schema rather than extending 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?

States a specific verb and resource — 'Get one public Venice character by slug' — which distinguishes it from the listing sibling venice_list_characters by the singular scope and slug lookup. It does not explicitly name the sibling, but the singular/plural distinction is clear.

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: use this when you already know a character's slug and want that one record. There is no explicit statement of when to prefer venice_list_characters (discovery) over this tool, nor any note about what happens with an unknown slug.

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=false, openWorldHint=true, and destructiveHint=false, so safety is covered. The description adds genuinely useful context the annotations do not carry: the return payload shape (base64 PNG) and the auth model (x402 wallet with no Venice account, or API key). It omits cost, latency, and any note that the source image is not modified, and the 'Returns base64 PNG' claim sits awkwardly against the output_format enum.

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 core action front-loaded, output disclosed second, and auth last. Nothing is padded and nothing is buried.

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

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

For an 8-parameter generation tool with no output schema, the description covers action, return type, and authentication, which are the critical unknowns. It leaves the agent without guidance on the optional knobs (safe_mode, enhance_prompt cost implications, resolution tiers) and without any cost or latency 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 63%, with safe_mode, output_format, and prompt undocumented anywhere. The description adds no parameter-level meaning at all, and its flat 'Returns base64 PNG' claim actually conflicts with the output_format enum that permits jpeg/webp.

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 ('Edit an image with a prompt') and implies the differentiator versus siblings like venice_image_multi_edit and venice_image_upscale via the single-image-plus-prompt framing. However, it never names those siblings, so an agent must infer the boundary 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?

There is no when-to-use guidance: no statement about when to prefer this over venice_image_multi_edit, venice_image_generate, or venice_image_upscale, and no prerequisites or exclusions. The agent gets a capability statement but no routing rule.

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 openWorldHint=true and non-idempotent, non-destructive writes, but the description adds genuinely non-structured context: content policy for NSFW prompts and two distinct authentication paths (x402 wallet vs. API key). What it omits is cost/credit impact and the difference between binary and non-binary responses, which is the gate for `variants`.

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?

It leads with the core action in three words and follows with the two facts an agent most needs (model coverage, auth options). The model enumeration is somewhat bulky but each named family earns its place by hinting at available `model` values.

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 18-parameter generative tool with no output schema, the description should say what comes back (image URL vs. base64 binary, since `variants` only works with non-binary responses) and give a default size/format hint. Auth and content policy are covered, but the return shape and cost implications remain 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 description's model list maps loosely onto the `model` parameter (which defaults to flux-2-pro per the schema) but does not enumerate valid string values or explain the interaction between `model` and the model-specific `resolution`, `aspect_ratio`, `quality`, and `style_references` options. At 56% schema coverage across 18 parameters, the description adds only marginal meaning beyond the schema, so a 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?

"Generate an image" is a specific verb+resource and the named model families (Flux 2 Pro/Max, Lustify SDXL, Qwen Image, GPT Image) make clear this is text-to-image synthesis rather than editing or upscaling. It stops short of explicitly naming siblings like venice_image_edit or venice_image_upscale, so the differentiation is inferred rather than stated.

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 useful context (NSFW prompts allowed where the model permits, x402 wallet auth means no Venice account is required, or use an API key), which tells an agent about access prerequisites. However, there is no explicit when-to-use vs. when-not guidance and no pointer to venice_image_edit for modifying an existing image, so the routing is left implied.

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 the operation profile (openWorldHint, non-idempotent, non-destructive), and the description adds genuinely useful context beyond them: the output is a base64 payload and two auth paths exist (x402 wallet or API key, no Venice account required). Minor gap: the 'Returns base64 PNG' claim is not reconciled with the output_format enum that also permits jpeg/webp.

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, purpose front-loaded, no filler. The 'Returns base64 PNG' sentence earns its place but should have been qualified to avoid implying PNG-only 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?

With 8 parameters, no output schema, and half the schema undocumented, the definition covers purpose, return shape, and auth but leaves parameter behavior and cost/pricing implications (explicitly flagged in the quality and enhance_prompt schemas) unaddressed. Adequate, not complete.

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

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

Schema coverage is only 50% across 8 parameters, so the description needs to compensate and does not. It never explains model, resolution, output_format, enhance_prompt, or limits like the 8-image max or whether image_urls accept remote URLs only — the only parameter-adjacent statement is the PNG return claim, which conflicts with the enum.

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 ('edit multiple images together with a single prompt') and clarifies the capability as multi-image composition / outpainting. The word 'multiple' implicitly distinguishes it from sibling venice_image_edit, but no sibling is named 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?

'Multiple images' plus 'multi-image composition / outpainting' implies when to pick this over venice_image_edit or venice_image_generate, but the description never says so directly and offers no exclusions or prerequisites.

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

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

Annotations already declare the safety profile (not read-only, open-world, not idempotent, non-destructive), and the description adds genuinely new facts: the return is a transparent PNG in base64, and either x402 wallet auth or an API key works. It does not disclose cost, size limits, or processing behavior, so it adds moderate value over the annotations.

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

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

The description is one front-loaded sentence that pairs the action and the output, with the auth detail trailing. Efficient, though the semicolon clause is a compact list, and it could carry one more constraint without bloat.

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 one-parameter tool, the description covers purpose, output format, and auth, which is what annotations and schema don't supply. It still leaves input constraints and the cost or side-effect of the paid call unstated, which matters for a non-read-only, open-world operation.

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 the single parameter, so the description has to explain image_url, and it doesn't: nothing about accepted formats, whether the URL must be publicly reachable, or size or type limits. The agent can guess the parameter means 'image to process,' but the description compensates for none of 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?

The description has a specific verb and resource ("Remove image background") and states the output, which cleanly separates it from generate/edit/upscale siblings. It doesn't explicitly name the sibling it contrasts with, but the operation name is unambiguous.

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

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

Usage is only implied by the operation name; there is no explicit when-to-use or when-not-to-use guidance versus venice_image_edit or venice_image_multi_edit. The auth note (x402 wallet or API key) gives useful framing but is not selection guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive, so safety is covered; the description adds a genuinely useful behavioral fact not in the annotations — that no authentication is required — which matters for an agent deciding whether it can call this cheaply up front.

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 purpose front-loaded before the auth note.

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-parameter, no-output-schema listing tool the description is nearly sufficient, but with no output schema it could say what the list actually contains (style names/ids usable in venice_image_generate) to close the last 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?

The tool takes zero parameters, so there is nothing for the description to disambiguate; 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 verb ('List') and resource ('image style presets'), and ties itself to the consuming sibling venice_image_generate, so an agent can tell it apart from the other image tools without opening a schema.

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

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

The reference to venice_image_generate implies this is the discovery step before generation, which is useful context, but there is no explicit when-to-use statement, no exclusions, and no named alternative for the same information.

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 beyond the annotations by explaining that the endpoint requires base64, so the tool fetches the URL and uploads it, and that the result comes back as base64 PNG. It also discloses the two auth paths (x402 wallet with no Venice account, or API key), which is meaningful context for an open-world, non-idempotent call. It does not mention cost implications of x402 payment or request limits.

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 the action, followed by the data-flow caveat and auth options. Nothing is redundant or padded.

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

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

Covers what the tool does, how the image is transported, the return format, and the auth paths, which is sufficient for a 3-parameter tool with a fully-annotated schema and no output schema. Only billing/cost behavior for the x402 path 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?

Schema description coverage is 100%, so all three parameters are already documented, and the only parameter detail in the description (2-4× scale) simply restates the schema. Baseline 3 applies because the schema carries the semantic load.

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: "Upscale an image (2-4× scale)". This clearly separates it from siblings like venice_image_generate, venice_image_edit, and venice_image_remove_bg, though no sibling is named 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?

Usage is only implied: call it when you have an image that needs upscaling. There is no explicit when-to-use/when-not guidance and no routing to alternatives such as venice_image_edit for other transformations.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive semantics, so the bar is lower. The description adds meaningful context beyond that: the admin-only requirement, the auth-path exclusion (x402), and the partial-data return (last six characters only). It does not cover rate limits or pagination, but the security-relevant additions are valuable.

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, each front-loading a distinct fact: what is returned, who can call it, and what auth path is excluded. 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 a zero-parameter, read-only listing endpoint with no output schema, the description covers purpose, access control, and data-exposure scope. Return-shape details are absent, but the key operational constraints an agent needs are present.

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, so baseline is 4. The schema is empty and the description correctly notes no inputs are needed, while adding auth-context constraints that function as implicit prerequisites.

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 (List) and resource (API-key metadata) and immediately clarifies scope: only the last six characters, not full secrets. This distinguishes it from sibling venice_get_api_key and sets expectations precisely.

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 admin requirement and that inference keys cannot call the endpoint, plus that x402 wallet auth is not accepted. Clear conditions on when the tool is usable, though it does not explicitly contrast with siblings like venice_get_api_key or venice_api_key_rate_limits.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so safety is covered. The description adds non-redundant behavioral context by disclosing the authentication constraint and the x402 exclusion, which the agent cannot infer from the schema. It omits pagination/sorting defaults and any indication of result size, keeping 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?

Two sentences, both front-loaded and free of filler; the resource is identified first and the auth caveat second. Nothing is wasted, though the extreme brevity is partly the source of the parameter gap.

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 tool with 12 optional parameters, near-zero schema descriptions, and no output schema, the description is far too thin. It never explains filtering, pagination behavior, default sort, or what a returned character record looks like, leaving the agent under-equipped to call it correctly.

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

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

Schema description coverage is only 8% across 12 parameters – only the deprecated 'tag' field carries any documentation. The description explains none of the meaningful filters (tags, categories, isPro, isAdult, search, sortBy, sortOrder, limit/offset, modelId), so an agent must guess at semantics and interactions from names and enums alone.

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 ('List public Venice characters'), which clearly separates it from siblings like venice_get_character and venice_chat_with_character. It does not explicitly name those siblings, but the 'list public' framing is unambiguous.

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

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

It supplies a real usage prerequisite ('API key required — this endpoint does not accept x402 wallet auth'), which tells the agent which credential path to take. However, it gives no guidance on when to pick this over venice_get_character, venice_character_reviews, or venice_chat_with_character, so the when-to-use logic is only implied by 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 already establish readOnly/idempotent/non-destructive, but the description adds valuable context beyond them: 'No authentication required', the upstream type=all behavior, the pagination contract, and the shape of returned entries. Only missing piece is any error or rate-limit behavior.

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-loaded with the core action and dense but purposeful; the pagination instruction and return-shape sentence each earn their place. Slightly heavy on semicolon-chained clauses, but nothing is wasted.

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

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

With no output schema, the description carries the return contract itself — naming total, next_offset, ids, and the compact-summary fields — and explains the pagination termination condition. An agent has everything needed to call and iterate 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 real nuance: it resolves the apparent tension in the schema by explaining omission is sent upstream as type=all, and clarifies that verbose switches between compact summaries and full objects beyond the schema's terse wording.

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 the live model catalog') and clarifies the scope (one page at a time, compact summaries). An agent can distinguish it from detail-oriented siblings like venice_model_details or venice_model_traits, though the description never names those alternatives 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 clear operational context: omitting type fetches all types, and gives an explicit pagination loop ('call again with offset=next_offset until next_offset is null'). It does not, however, state when to prefer this tool over sibling catalog/inspection tools.

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

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

Annotations already declare the safe read profile (readOnly, idempotent, non-destructive). The description adds genuinely new context: the mapping is 'live', no authentication is required, and the API defaults to text when type is omitted. These are behavioral facts not present in the annotations or schema.

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

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

Three short sentences, front-loaded with the core purpose, then the default and auth note. No filler; 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?

For a single-optional-parameter read tool with full annotation coverage and no output schema, the definition is nearly complete. The only gap is routing guidance relative to the other model-listing tools, but nothing needed to call 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?

Schema description coverage is 100%, and the schema already documents the 'type' parameter with its full enum-like catalog list and default. The description restates the default-to-text behavior, adding no syntax or format detail beyond the schema, 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 states a specific verb and resource: 'Return the live compatible model-name to Venice model-id mapping for a model type.' This is clearly distinct from siblings like venice_list_models or venice_model_details, though it does not explicitly name those alternatives.

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

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

It notes the default behavior when 'type' is omitted, which implies usage context, but never says when to reach for this tool versus the model-related siblings (venice_list_models, venice_model_details, venice_model_traits). Usage is only implied.

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=false, so safety is covered. The description still adds real context: it is unauthenticated and only returns pricing 'when available', which the annotations do not say.

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 the return payload, followed by the parameter rationale and the auth note. No filler and nothing repeated from title or schema.

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 carries the burden of describing the return payload and its conditionality ('pricing when available'), plus auth status. It stops short of noting error behavior for an unknown model_id/type pair, which is the only real 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 coverage is 100%, so the baseline is 3, but the description adds rationale the schema lacks: the 'type' parameter is required to keep the upstream catalog response bounded. That explains motivation without merely restating the field set.

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

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

The description uses a specific verb and resource ('Get one exact model's full catalog row') and enumerates the payload contents (model_spec constraints, capabilities, pricing). It is clearly distinguishable from the sibling venice_list_models, which returns many rows rather than one.

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 the lookup use case ('one exact model') and the schema example points back to venice_list_models({type: "video"}), but the description itself never states when to prefer this over venice_list_models or venice_model_traits. Usage is inferable rather than 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 already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds two useful behavioral facts beyond them: the mapping is "live" (not cached) and "No authentication required." It does not describe the response shape or size, so this is solid but not rich.

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 purpose, then the default, then the auth note. Every sentence carries a distinct fact and nothing is padded.

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

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

With no output schema, the description carries the burden of explaining the return value, and it does so adequately ("trait-name to model-id mapping"). But for a catalog-inspection tool with many sibling metadata tools, it lacks any routing guidance, leaving a real 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 100% and the single parameter is fully documented in the schema, including the "Defaults to text upstream" note that the description merely restates. Baseline 3 applies since the schema does the heavy lifting and the description adds no new parameter meaning.

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: "Return the live trait-name to model-id mapping for a model type." An agent knows what it fetches. However, it never distinguishes itself from sibling model-metadata tools like venice_model_details, venice_list_models, or venice_model_compatibility_mapping.

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

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

No when-to-use guidance and no named alternatives. The only context given is an upstream default, which is a parameter behavior rather than a usage rule. An agent cannot tell from this text when to prefer it over venice_model_details or venice_model_compatibility_mapping.

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 destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the bar is lower. The description still adds real value beyond them: it names what is destroyed ('server-side media'), gives a success-confirmation contract ('reports removal only when Venice confirms success'), and discloses auth modes (x402 wallet or API 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?

Three short sentences, the destructive action and its effect front-loaded, followed by the confirmation contract and auth options. 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?

Behaviorally solid for a destructive mutation with no output schema, but with 0% schema coverage on two required params the description should have explained queue_id/model matching semantics. The tool is callable, but an agent could easily pass the wrong model and misfire a destructive operation.

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 two required parameters, so the description carries the full burden and largely fails it. It never explains what queue_id identifies or whether 'model' must match the model used at generation time, which is a real ambiguity for a destructive call.

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 precise verb and resource: 'Mark a completed music job as downloaded and delete server-side media.' It is unambiguously distinct from venice_music_generate, venice_music_status, and the video equivalents in the sibling list.

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 precondition 'a completed music job' implicitly routes the agent to check status (venice_music_status) before calling, and the name signals it is a terminal cleanup step. No explicit when-not or named alternative is given, so it stops 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 cover the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false), and the description adds substantial context beyond them: dual auth paths (x402 wallet with no account, or API key), the NSFW/uncensored policy where models permit, and the exact return payload { model, queue_id }. This is rich, non-redundant behavioral disclosure.

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?

Purpose is front-loaded and the sentence structure is dense and information-bearing. The enumerated model list is long but functional for model selection, so it earns its space, though it slightly inflates the text.

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 stating the return shape and the required follow-up (poll via venice_music_status), and it covers auth, model availability, and content policy. An agent has what it needs to invoke and then track the job.

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 92%, so the schema already documents the 12 parameters thoroughly; the description's model list is the only meaningful cross-reference to the 'model' parameter. Baseline 3 is appropriate since the description does not add syntax or behavior detail 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 ('Queue music generation') and immediately differentiates the async queue flow from siblings by instructing the agent to poll with venice_music_status. The listed models and the returned shape make the tool's identity unambiguous.

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

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

The polling workflow ('poll with venice_music_status') gives clear operational context for using the result, and the auth options tell the agent how access is obtained. It does not, however, explicitly contrast this async tool against venice_music_complete (sync) for the same resource, which would be the natural when-to-use guidance.

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

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

Adds real context beyond the annotations: it discloses the transport (POST with body {model, queue_id}), the intermediate return shape (JSON progress while PROCESSING), the two terminal shapes (embedded base64 resource vs download_url link), and the auth options (x402 wallet or API key). It does not explain why destructiveHint=true — i.e., that media can be deleted server-side — so the destructive profile is left to the annotations.

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

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

Four short clauses, front-loaded with the core action, then return shapes, then transport, then auth. No filler, though the auth clause is slightly tangential to a status check and could be trimmed.

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 carry the return contract, and it does describe the PROCESSING and completed shapes reasonably well. It omits failure/expiry states, polling cadence, and the consequences of the destructive flag, which matter for a queue-status 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 only 33%, and the description partly compensates by stating the request body is {model, queue_id} and that download_url results need a separate fetch step. It still doesn't clarify what model means for a status lookup (must it match the enqueue-time model?) or the media-deletion lifecycle, leaving a gap against the low coverage.

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

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

States a specific verb+resource: 'Check status of a queued music job.' An agent can distinguish this from venice_music_generate (which enqueues) and venice_music_complete, though neither sibling is named explicitly in the description.

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 'queued music job' and by the note that completed jobs return audio or a download_url, which tells the agent this is a polling tool. However, it never states when to call it (after venice_music_generate), how often to poll, or when to hand off to venice_music_complete instead — that routing only appears inside the schema for delete_media_on_completion.

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 supply the generic safe-mutation profile (readOnlyHint=false, destructiveHint=false, openWorldHint=true), and the description adds substantial context beyond that: alpha stability, statelessness, deliberate omission of tool-calling fields, E2EE model exclusion, content policy, and two auth modes (x402 wallet or API key). It still omits cost/credit implications and whether output streams, which matter for a paid generation call.

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 with the identity and stateless/alpha qualifier front-loaded, then constraints, then auth. No filler. The only mild weakness is that the auth sentence arrives last and reads as a list rather than routing 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 and a deeply nested input, the description covers environment and constraints well but leaves the agent without any picture of the return value or how generation output/usage is surfaced. For a seven-parameter nested object with 29% schema coverage, some of that gap should have been closed in prose.

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

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

Schema description coverage is only 29%, so the description carries a real burden that it largely does not meet. It gestures at 'text/image input and reasoning controls', but model, temperature, top_p, and max_output_tokens are entirely unexplained, and the seven-value reasoning.effort enum is never characterized (e.g., which models honor 'xhigh'/'max').

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

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

The description names a specific API surface ('OpenAI-compatible Responses API') for a specific resource (Venice text models) and flags it as stateless and alpha. It falls short of full sibling differentiation: nothing explains why an agent would pick this over venice_chat or venice_chat_with_character, both of which are text-generation siblings in the list.

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?

Negative guidance is present and useful: no tool calling, no E2EE models, NSFW allowed where the model permits. But there is no positive routing guidance telling the agent when this endpoint is the right choice versus venice_chat, nor any mention of how to pick a model (venice_list_models) before calling.

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 the description adds real context beyond them: no authentication is required, and crucially that fetching the evidence 'does not itself establish E2EE', which prevents a false sense of security. It stops short of disclosing caching/rate-limit behavior or exactly how the echoed values are structured for comparison.

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, purpose front-loaded, followed by the caller obligation and the security caveat. Every clause carries operational weight and nothing is 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?

Despite no output schema, the description enumerates what comes back (echoed nonce, Intel TDX quote, optional NVIDIA evidence, debug-mode state, signing-key binding), covering the return shape for the agent. Combined with the auth and verification notes, an agent has enough to invoke and interpret the call.

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 'model' and 'nonce' fully documented in the schema (including the 64-hex-char pattern that the description restates as '32-byte'). The description echoes the schema rather than adding syntax or format detail beyond it, 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 (Fetch) and resource (hardware-attestation evidence for a TEE-capable text model), so an agent knows exactly what the tool returns. It does not, however, differentiate itself from the closely related sibling venice_tee_signature, which an agent would need clarified before choosing between 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?

Usage is implied through the freshness requirement ('must supply a fresh 32-byte nonce') and the verification chain 'before trusting the key', which tells the agent this is a pre-trust evidence step. There is no explicit when-to-use vs. when-not, and no routing to the sibling venice_tee_signature, leaving selection 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 already declare readOnly, idempotent, non-destructive, and closed-world, so safety is covered. The description adds real value beyond them by stating that no authentication is required and that the tool returns only the provider payload without performing verification, which sets the caller's obligation. It stops short of describing failure behavior for non-TEE or incomplete requests.

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 the action and resource, followed by the verification contract and the auth note. Nothing is redundant and every sentence carries information an agent needs.

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 read tool with no output schema, the description covers the essential context: what it returns, that verification is the caller's responsibility, and that no auth is needed. The one gap is the shape of the returned signature payload, which is not characterized at all.

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 already carry descriptions that explain provenance (model from chat completion metadata, request_id from venice_chat or venice_chat_with_character). The description adds no parameter-level meaning beyond the schema, so the baseline of 3 applies.

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

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

The description gives a specific verb and resource ('Fetch the enclave signature') scoped to 'a completed TEE text-model chat request,' which clearly separates it from the general chat and attestation siblings. It gestures at venice_tee_attestation without naming it, so the differentiation is clear in substance but not in explicit routing.

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 context is well established: the request must be a completed TEE text-model chat, and the signature must be verified against a signing identity from a separately verified attestation. There is no explicit 'do not use this if' clause and no named prerequisite tool call, which keeps it 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?

Beyond the annotations, the description discloses genuinely useful behavior: the URL is fetched server-side, the file is uploaded as multipart/form-data, and both x402 wallet auth and API key auth are accepted. This is exactly the kind of operational context annotations cannot express. It stops short of 5 because it says nothing about size/page limits, failure modes, or cost implications, and readOnlyHint=false is left unexplained.

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 core action, then behavior, then auth. Every sentence carries information with no filler. It is slightly under-terse in that supported formats live in the title rather than the description body.

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 parser with no output schema, the definition should say roughly what comes back (raw text, per-page text, metadata) and restate supported formats inline. Auth modes and server-side fetching are covered, but return-shape expectations are left entirely to inference.

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 parameter's own description already spells out http(s) URLs vs. base64 data URLs with required media types. The description adds only the 'fetched server-side' nuance, which clarifies that no local upload step is needed but does not extend coverage of the single parameter.

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: 'Extract text from a document URL.' The title adds the supported formats (PDF/DOCX/EPUB/PPTX/XLSX), so an agent knows this is a document-to-text tool rather than a general scraper. It does not explicitly distinguish itself from siblings like venice_web_scrape, so it falls 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?

There is no when-to-use or when-not-to-use guidance, and no mention of the obvious alternative (venice_web_scrape for HTML pages vs. this tool for binary documents). The only contextual hint is the auth note, which is about credentials, not tool selection.

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 a generic mutation/non-idempotent profile with no side-effect detail. The description adds high-value behavioral context beyond annotations: it discloses that streaming=true does NOT emit incremental MCP chunks because the tool buffers the complete audio, and it documents dual auth paths (x402 wallet with no Venice account vs API key). These are exactly the non-obvious traits 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 sentences, front-loaded with the core purpose and then the two highest-value caveats (streaming buffering, auth options). Dense but every sentence earns its place; no filler or tautology.

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, so the description should hint at return shape and it does implicitly ('returns one complete audio result'). Combined with the streaming caveat and auth coverage, it is nearly complete for a TTS tool. Minor gap: it never states the default response format or expected output container.

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 57%, above the threshold where the schema alone is deemed sufficient, so a baseline of 3 applies. The description reinforces the streaming semantics already noted in the schema and mentions the emotion-tag input syntax, but adds no detail on model, speed, temperature, or response_format beyond what the schema provides.

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

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

States a specific verb and resource ('Convert text to speech') and immediately differentiates scope by listing distinctive capabilities (cloned voices, emotion tags). An agent can distinguish this from siblings like venice_asr (the inverse task) and venice_voice_clone without opening the schema.

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

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

The description implies usage via capabilities (cloned voices, emotion tags, streaming) but never states when to use this tool versus alternatives such as venice_asr or venice_music_generate, nor any prerequisite conditions. Usage context is left to inference from the capabilities listed.

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 destructiveHint=true, idempotentHint=true, and readOnlyHint=false. The description adds useful context beyond them: removal is reported only when Venice confirms success, and auth can be x402 wallet (no Venice account) or API key. These are valuable behavioral/auth details not carried by the annotations.

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

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

Three tight sentences with zero waste; the core action is front-loaded and the confirmation/auth notes follow. Appropriately sized for the operation.

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 destructive nature makes behavioral detail important; the description covers auth and confirmation semantics well. However, it leaves both parameters completely unexplained and gives no return/error detail, so it is only adequate for a destructive two-param 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 0% and both parameters (queue_id, model) are undocumented in the schema. The description mentions neither, so it fails to compensate for the coverage gap. An agent gets no semantic help on what queue_id or model must contain.

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: 'Mark a completed video as downloaded and delete server-side media.' This clearly distinguishes the cleanup action from siblings like venice_video_status and venice_video_generate. It is clear but does not explicitly name or contrast a sibling.

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

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

The phrase 'a completed video' implies the tool is used after a video finishes and has been downloaded, but there is no explicit when-to-use or when-not guidance and no named alternative such as venice_video_status for checking status first. Usage 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.

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

Goes well beyond the annotations (readOnlyHint=false, idempotentHint=false, openWorldHint=true) by disclosing the two auth modes (x402 wallet or API key), the async return shape { model, queue_id }, NSFW content behavior, and the fact that Seedance may reject detectable persons regardless of consent. The warning that consent flags are 'defensive compatibility support, not a policy bypass' is exactly the kind of policy context annotations cannot carry.

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 core action and follows with structured guidance (models, auth, return, polling, caveats) rather than prose. The example-id list and the double caveat about Seedance persons/consents are somewhat repetitive with the schema descriptions, costing a little density.

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 19-parameter, nested-object, no-output-schema async job tool, the description supplies the return shape, the polling path, auth options, and the consent precondition. Remaining gaps are cost/quote workflow and failure/error behavior, which an agent might reasonably need before committing a job.

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 89% schema coverage the schema already documents most parameters, so baseline is 3; the description adds value by clustering model ids by family and flagging that 'duration' is a model-specific string enum to be inspected via venice_model_details, plus the Seedance person-rejection caveat that explains consents. It stays silent on seed, upscale_factor and the element reference syntax 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?

Opens with a specific verb+resource ('Queue a video generation') and immediately scopes it with the supported model families and concrete example ids such as "veo3.1-fast-text-to-video". The closing instruction to 'poll with venice_video_status' separates it cleanly from the status/complete 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 to venice_video_status for polling and venice_model_details for duration/resolution, and gives a clear precondition for the consent flags (show returned policy, get explicit confirmation). It does not mention whether to call venice_video_quote first for pricing, which is the one obvious alternative left unaddressed.

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 closed-world, so the safety profile is covered. The description adds two genuinely useful facts beyond that: no authentication is required, and the call happens before queuing (so it does not consume/enqueue a job).

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

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

Two short sentences, front-loaded with the core purpose and the pre-queue constraint. No filler or redundancy.

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

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

For a two-parameter, read-only quote tool this is nearly complete. The one gap is that no output schema exists and the description does not hint at what the quote returns (e.g., credit/cost fields), which an agent may want to know before parsing the 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 description coverage is 100%, so both parameters (model, duration) are fully documented in the schema itself. The description adds no format, enum, or constraint detail beyond it, which is the correct baseline when the schema does the work.

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 (get a price quote) and resource (video generation), with the temporal qualifier 'BEFORE queuing' that separates it from venice_video_generate. The sibling venice_audio_quote confirms the quote-then-generate pattern, and this tool is clearly the video variant.

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?

'BEFORE queuing' tells the agent this is a pre-flight step, which implies it should be called prior to venice_video_generate. It gives clear context but never names the alternative tool explicitly or states when a quote is unnecessary.

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 destructiveHint=true and idempotentHint=true, but the description explains why destruction occurs: delete_media_on_completion removes server-side media once the MP4 is buffered. It also discloses auth modes (x402 wallet or API key) and the POST body shape, which annotations cannot convey. It doesn't cover failure/expiry behavior for a queue_id, so not 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?

Front-loaded with the core purpose, which is good, but the VPS / Grok Imagine Private sentence is dense and duplicates schema text about the retrieve endpoint returning COMPLETED without a URL. The prose is jargon-heavy ('this process reuses the queue-time download_url') and would benefit from trimming or bullets.

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 describe the three result shapes (progress JSON, base64 resource, download_url link). Combined with the destructive-parameter explanation and auth notes, an agent has enough to call it correctly. Missing only operational detail such as what a pending/expired queue_id looks like.

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 all four parameters are already fully documented, establishing a baseline of 3. The description adds limited extra meaning, mainly restating that the body is {model, queue_id} and reiterating the VPS download_url fallback already spelled out in the schema. No new format, default, or constraint information 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?

Opens with a specific verb+resource ('Check status of a queued video job') and immediately characterizes the two possible completed outcomes (embedded base64 resource vs download_url link). It is clearly distinguishable from venice_video_generate (queueing) and venice_video_complete (post-download cleanup), though those siblings are only referenced indirectly rather than named as alternatives.

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 rather than stated: the agent infers this is a polling step after venice_video_generate. The only explicit routing is 'download first, then call venice_video_complete' for download_url results, which is narrow. There is no guidance on polling cadence, when to stop, or when to prefer another tool.

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 openWorld and non-idempotent, but the description adds material context the annotations cannot: list is an auth-free GET, create uploads a sample to a POST endpoint, and the tool accepts either x402 wallet auth or an API key. It also clarifies that the mixed read/write nature is split by action, which reconciles the coarse readOnlyHint=false. It omits cost/rate-limit and repeat-clone behavior for the create path.

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-loaded with the purpose, then ordered list-then-create, then the downstream handle handoff. Every sentence carries a fact, though the raw endpoint paths (GET /v1/models?type=tts, POST /v1/audio/voices) are somewhat internal detail that could be trimmed for an agent-facing 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?

With no output schema, the description carries the return-value burden: it explains the vv_<id> handle from create and characterizes list output as per-model voice metadata. The list response shape is only loosely described, which is the remaining gap for a two-mode 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 100%, so the baseline is 3, but the description adds semantics the schema lacks: model is the cloning model the voice is bound to and must match at synthesis time, and sample_url is mandatory only for create. This is real added meaning rather than a restatement of the enum descriptions.

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 first sentence names a specific verb pair and resource ('Discover or clone TTS voices'), and the following sentences split the two modes by action name and backing endpoint. An agent can distinguish this from venice_tts (synthesis) and venice_list_models (general model listing) 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?

It clearly conditions each action: 'list' for reading live voice metadata, 'create' when a sample_url is available, and it routes the agent forward by saying the returned handle is passed to venice_tts with the same model. It stops short of explicit when-not guidance (e.g., when to prefer list over venice_list_models, or when cloning is unnecessary).

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=false, openWorldHint=true, idempotentHint=false and destructiveHint=false, so the safety profile is covered structurally. The description adds genuinely useful context the annotations do not: dual auth via x402 wallet (no Venice account required) or API key. It does not disclose failure behavior or rate limits.

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

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

Two short sentences with no filler, and the core action is front-loaded before the auth detail. Efficient, though it could have folded in the format options at no extra length.

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 scrape tool with no output schema, the auth disclosure is a real plus, but the description omits the non-markdown output formats, error/rate-limit behavior, and any note on external-resource variability implied by openWorldHint=true. Adequate but with clear gaps.

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 the parameter burden. It only mentions markdown output, which corresponds to one enum value, and says nothing about the html/text alternatives the format parameter offers, nor any constraints on the URL. The url parameter is self-evident but format is under-explained.

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 (Scrape) and resource (one URL) plus the output form (markdown text). The word 'one' implicitly distinguishes it from the sibling venice_web_search, but the sibling is never named, so an agent gets a clear purpose without explicit 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 description explains authentication options but gives no when-to-use guidance or alternatives, e.g. when to scrape a single URL versus calling venice_web_search. The agent must infer the selection criteria on its own.

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 openWorldHint=true and readOnlyHint=false; the description adds substantive context beyond them: the data-retention profile of each provider, the return shape (titles, URLs, snippets, dates), and that x402 wallet auth works without a Venice account. It does not mention cost per search or rate limits, which matters given the non-readOnly flag.

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 capability, then the return shape, then auth. Nothing is redundant, though the final auth sentence is compressed to the point of being slightly cryptic about how the two auth modes are selected.

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 spells out the return fields, and it covers provider choice and auth. It leaves a gap around result volume/pagination and per-call cost, which an agent spending wallet funds would want to know, but overall it is adequate for a three-parameter read 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 only 33%, and the only schema-described parameter is search_provider, whose description the tool text largely repeats. The description says nothing about what `limit` bounds (1-20) or the `query` length cap of 400 characters, so it does not compensate for the coverage gap; 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 specific verb and resource ('Search the web') and enumerates the three backing providers, so the agent knows exactly what the tool does. It stops short of naming the closest sibling, venice_web_scrape, so the search-vs-scrape distinction must be inferred from the verb alone.

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 a default provider ('Brave Search (default)') and the privacy tradeoffs that would drive provider selection, which is real selection guidance. However, it never states when to reach for this tool versus venice_web_scrape, nor any exclusion or prerequisite conditions, so usage is only implied.

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 the safety profile (readOnly, idempotent, non-destructive), and the description adds genuinely new behavioral context: API key auth is rejected and the wallet must match the SIWX-authenticated identity. It does not describe response shape or error behavior, but the auth constraint is the key disclosure.

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 with no filler: purpose first, then the auth constraint and identity-match requirement front-loaded as the operative caveats.

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-param read tool with no output schema, the description covers purpose, auth mode, and identity matching. It could briefly note the returned balance unit/format, 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?

Schema coverage is 0%, so the description must compensate for the single path parameter. It specifies the accepted address families (EVM or Solana) and the identity-match constraint, adding real meaning beyond the bare pattern in 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 (Check) and resource (prepaid x402 credit balance) scoped to EVM or Solana wallet addresses. This clearly separates it from sibling billing/x402 tools like venice_billing_balance and venice_x402_transactions.

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 declares SIWX-ONLY usage and that API key auth is rejected, plus the constraint that the path wallet must match the SIWX-authenticated wallet. It does not name a sibling alternative for API-key callers (e.g., venice_billing_balance), so it stops short of full when/when-not 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 declare readOnly/idempotent/non-destructive, but the description adds several things they cannot: it is an empty POST with no payment header, nothing is charged, no authentication is required, and signing occurs outside this server. That goes well beyond the safety profile.

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-loaded with the core action and purpose, then the return fields, then the behavioral caveats. Every sentence carries information; only the parenthetical field list makes it slightly dense, but nothing is wasted.

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

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

With no output schema, the description carries the burden of describing the response and does so fully (accepted USDC options, Base/Solana, payTo, minimum base units, settlement timeout). An agent has everything needed to call and interpret it.

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 per the calibration the baseline is 4. There is nothing further for the description to disambiguate.

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

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

States a specific verb (Fetch) and resource (x402 top-up payment requirements) and enumerates the exact payload fields returned (network, asset, payTo, minimum amount, settlement timeout). The agent can distinguish it from venice_x402_balance and venice_x402_transactions 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?

Frames the call as the discovery step before payment and clarifies that signing/PAYMENT-SIGNATURE submission happens outside the MCP server, which tells the agent where this tool's responsibility ends. It does not explicitly name an alternative or exclusion, so it falls 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 the safety profile (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new behavioral context: SIWX-only authentication, API keys are rejected, and the path wallet must match the SIWX-authenticated wallet. It stops short of describing ordering, pagination, or result shape, so it is strong but not exhaustive.

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 tight sentences, front-loaded with the core action and immediately followed by the hard constraint. Every clause carries information; nothing is 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 a read-only listing tool with no output schema, the description supplies purpose, auth model, and the wallet-matching rule. Missing only secondary details like ordering, default limit behavior, and pagination, which are minor for a tool of this complexity.

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

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

Schema description coverage is 0%, so the description must carry the burden. It partially compensates by explaining that the wallet is EVM or Solana (clarifying the address formats) and that it must match the authenticated wallet, but the limit parameter (1-100) and its effect on result size are never mentioned.

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 (List) and a precisely scoped resource (recent x402 top-up + debit transactions) qualified by wallet type (EVM or Solana). This cleanly separates it from sibling x402 tools like venice_x402_balance and venice_x402_top_up_info without needing to name 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?

Usage is implied by the resource (fetch transaction history for a wallet), and the auth precondition narrows the audience, but there is no explicit 'use this instead of / in addition to' routing against venice_x402_balance or venice_billing_usage_history. Adequate but leaves the agent to infer the selection criteria.

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