Real Real Genuine

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

With no annotations, the description carries the burden of behavioral disclosure. It provides useful context on trust levels (standard, trusted, premium) and their thresholds, but it does not explicitly state that this is a read-only operation, mention return format, or address any network/auth requirements. The additional info about trust benefits is helpful but not fully comprehensive.

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 extremely concise and front-loaded with the key verb and resource. The trust level definitions are presented as a compact, scannable list. Every sentence adds value with no wasted words.

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 tool is simple (one parameter, no output schema), and the description adequately explains its purpose and the meaning of trust levels. It does not explicitly describe the return value format, but 'check your standing' implies the output is your current trust level. Given the low complexity and complete schema, this is a minor gap, so a 4 is suitable.

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

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

The input schema fully describes the parameter (agent_wallet: string, pattern, description 'Agent wallet address on Base'), achieving 100% coverage. The description does not add any additional parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Check your on-chain trust standing across RRG brands (ERC-8004 reputation)'. It uses a specific verb ('check') and identifies the resource (on-chain trust standing) and scope (across RRG brands), distinguishing it from siblings like check_my_commissions or get_offers.

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 when to use the tool by explaining that higher trust unlocks 'better voucher offers and priority access', suggesting it's useful before purchasing. However, it does not explicitly mention alternatives or when not to use it, nor does it compare with sibling tools like get_agent_readiness or get_offers.

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

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

With no annotations, the description carries the burden. It discloses behavior by stating 'Identified by wallet' and enumerating what is shown, implying a read-only operation. However, it does not address potential errors, permissions, 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?

The description is four short sentences, front-loaded with purpose, then details, identification method, and audience. Every sentence provides useful information with no filler.

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

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

For a simple one-parameter read tool with no output schema, the description covers purpose, returned data, and identification. It is sufficiently complete for most use cases, though explicit output format or error handling is not described.

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% with a description already explaining 'wallet_address'. The tool description adds 'Identified by wallet', reinforcing the parameter's role, but this is marginal 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?

The description specifies a clear verb ('Check') and resource ('referral / marketing / affiliate commission balance and history'), and details the outputs (total earned, pending payouts, paid-to-date, recent conversions). This distinguishes it from siblings like get_points_balance and get_offers.

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 clear context for use (commission balance/history inquiries) and explicitly states it works for both humans and AI agents. It does not mention alternatives or exclusions, but the use case is unambiguous.

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

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

With no annotations, the description fully discloses the tool's side effects: verifies on-chain transfer, mints ERC-1155 NFT, fires ERC-8004 reputation signals, distributes revenue, and returns a download URL. It also explains mandatory fields for physical products and why they are required (e.g., shipping_phone for delivery confirmation, buyerEmail for order confirmation).

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 compact for a complex tool, with each sentence serving a purpose. It front-loads the primary action and step context, then lists side effects and requirements. While not bulleted, it remains readable and avoids 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?

Given the tool's complexity (15 params, no output schema, no annotations), the description covers the essential context: when to call, what it does, required fields, and variant-matching validation. It does not mention error handling or failure scenarios, but the provided guidance is sufficient for an agent to invoke it correctly.

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

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

Schema coverage is 100%, so baseline is 3. The description adds meaningful context beyond schema by explicitly listing required fields for physical products, emphasizing that selected_size and selected_color must match the initiate_agent_purchase variant, and explaining buyerAgentId's role in on-chain trust signals.

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+resource combination: 'Confirm your USDC payment and claim the listing.' It clearly identifies this as Agent Step 2 and references initiate_agent_purchase, distinguishing it from the sibling confirm_purchase (which handles non-agent purchases).

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 states exactly when to call it: 'Call after sending USDC to the address returned by initiate_agent_purchase.' It provides clear context for when to use it, but does not explicitly mention when not to use it or name alternatives like confirm_purchase, leaving a minor gap.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It mentions gasless minting, return of a download link, and revenue split details, but does not disclose that this is likely an irreversible financial transaction or what happens on failure. The absence of warnings about fund transfer or consequences is a notable gap.

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

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

The description is concise and well-structured, with the purpose front-loaded and essential details presented in a few clear sentences. It avoids unnecessary repetition of the 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?

For a complex financial tool with no output schema, the description covers key context: it references initiate_purchase, explains on-chain minting, lists physical product requirements, and mentions response contents. It could be more complete with potential error outcomes, but it is sufficiently detailed for an agent to proceed.

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%, providing a baseline of 3. The description adds value by grouping and emphasizing the required fields for physical products, and explaining why shipping_phone and buyerEmail are necessary. This goes beyond the individual schema property 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 description clearly states the tool's function: 'Complete the purchase by submitting the signed EIP-712 permit from initiate_purchase' and specifies the on-chain minting of an ERC-1155 NFT. This distinguishes it from the sibling confirm_agent_purchase, which is agent-specific, by referencing the buyer's flow.

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 positions this as 'Step 2' after initiate_purchase, indicating when to use it. It provides specific conditional instructions for physical products but does not explicitly contrast with confirm_agent_purchase or state 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?

With no annotations, the description fully discloses the tool's behavior: it no longer creates anything, returns the VIA onboarding URL, and explains the historical consequences of using it (split identity). This is transparent and exceeds what structured data provides.

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

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

The description is front-loaded with the retirement status, then provides necessary historical context in a concise manner. Every sentence contributes to understanding the tool's deprecation and current behavior, with no fluff.

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 having 11 parameters and no output schema, the description sufficiently explains the tool's current behavior and why it exists. It covers the redirect to VIA and the rationale, making the tool's purpose and limitations fully understandable for an agent.

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. The description adds critical context: all parameters are effectively ignored because the tool is retired. This prevents the agent from wasting effort validating or filling parameters, adding value 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?

The description clearly states the tool is retired ('[RETIRED] This tool no longer creates anything') and specifies its current purpose: every call returns the VIA onboarding URL. This is a specific verb+resource+behavior, and it distinguishes itself from siblings by being deprecated.

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 warns against using this tool to actually create a concierge ('Creating an agent here produced a SECOND agent record...') and directs the owner to VIA ('Send the owner there'). It does not name an alternative sibling tool, but the guidance is clear: this should not be used for creation; instead, the agent should direct the owner to VIA.

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

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

No annotations are provided, so the description carries full burden. It discloses that commissions are paid in USDC to the wallet, that no approval is needed, and what the tool returns. It also explains how the ref_code is used for attribution, which is important behavioral context beyond just 'create link'.

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

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

The description is a single paragraph that front-loads the purpose, then explains the value proposition and usage. It's concise without being under-specified, and every sentence adds relevant detail.

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 annotations or output schema, the description provides a clear picture of the tool's behavior, return value, and integration with other tools. It covers eligibility, payment, and attribution. Minor missing details like idempotency or limits, but for a simple creation tool it is quite 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?

Both parameters have schema descriptions that are already informative (token_id as 'Token ID of the product you want to promote' and partner_wallet as 'Your Base wallet; commission is paid here'). The tool description doesn't add significant extra parameter-level detail beyond the schema, but it does clarify that the wallet receives commission, which is already in schema. 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?

The description clearly states 'Create a product referral link' with a specific verb and resource, and explains the commission mechanism. It distinguishes itself from siblings like log_referral by focusing on product referral links and mentioning how ref_code integrates with buy_product/confirm_purchase.

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 says 'Open to any wallet, no approval needed' and instructs to 'Share the link, or pass ref_code to buy_product / confirm_purchase'. This provides clear context for when to use the tool, though it doesn't explicitly state exclusions or alternatives beyond these related 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?

With no annotations provided, the description carries the burden of behavioral disclosure. It reveals key traits: 'The first discovery banks the reward to your wallet,' 'Returns the video URL,' and 'there is nothing to buy.' It does not mention failure modes or what happens on repeat discoveries, but the 'first discovery' phrasing implies the reward is one-time. This is solid 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?

The description is four sentences, front-loads the primary purpose, and each sentence adds value: prerequisite, gating logic, reward behavior, and return value. There is no fluff or redundancy, making it appropriately sized and well-structured.

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

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

Given the tool's moderate complexity and lack of output schema/annotations, the description covers the essential facets: what it does, source of input, gated vs. open handling, reward condition, return value, and a clarifying statement that it is not a purchase. It omits potential edge cases like undiscovered egg failures, but overall it is complete enough for an agent to use correctly.

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

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

Schema description coverage is 100%, with each parameter already described in the schema. The description largely repeats this information (e.g., 'egg_slug from get_world_eggs', 'answer for gated eggs'), adding little extra meaning beyond reinforcing the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the action (discover), the resource (easter egg from get_world_eggs), and the outcome (reveal its film). It also distinguishes this from listing tools and purchase tools by saying 'Eggs are content, not listings: there is nothing to buy.' This specificity differentiates it from siblings like get_world_eggs and initiate_purchase.

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 the prerequisite (use egg_slug from get_world_eggs) and provides conditional guidance for gated vs. open eggs. It also includes an exclusion ('nothing to buy') to prevent misuse. However, it does not explicitly name when not to use the tool or mention alternative tools, 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?

With no annotations provided, the description carries the full burden. It discloses the cost, benefits, limits (500 passes, max 5 per wallet), and that the tool returns payment instructions rather than executing the purchase. This is transparent about the tool's role and the process, though it doesn't detail what the payment instructions look like or any potential side effects.

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 moderately long but well-structured with a clear intro, bullet points for benefits, and a final instruction. Every sentence adds value—detailing cost, benefits, limits, and next steps. It is front-loaded with the main purpose and avoids fluff, though it could be slightly more compact without losing clarity.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description provides sufficient context: what the pass is, its value, limitations, and the follow-up required. It covers the user's journey well, though it doesn't describe the exact format of the payment instructions, which would be helpful but not critical.

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

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

The schema already fully describes the single parameter buyerWallet with its pattern and description. The description adds no new parameter semantics but provides context (max 5 per wallet) that relates to the parameter's usage. Since schema coverage is 100%, the description's lack of parameter-specific detail is acceptable, earning the baseline score.

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

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

The description clearly states the tool's purpose: to get the RRG Agent Pass Phase 1 founding membership. It specifies the action (get), the resource (Agent Pass), and the context (membership). It also distinguishes from siblings by noting it returns payment instructions and directs the next step to confirm_agent_purchase, differentiating it from initiate/confirm purchase tools.

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

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

The description provides a clear usage flow: call this to receive payment instructions, send USDC, then call confirm_agent_purchase with the txHash. It implies when to use this tool (to start the pass purchase) and names the follow-up tool, but does not explicitly state alternatives or when not to use it. Still, the guidance is strong and context-rich.

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

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

With no annotations, the description carries the full burden and does well by disclosing caching behavior (24h cache), return contents (score, percentage, band, URL, failing checks), and the scope (brand's own store, not RRG). It also implies read-only behavior via 'fetch the cached,' but could still mention authentication or side effects if any.

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 concise and well-structured, starting with a marketing context tag, then the core action, return data, usage, and caching. Every sentence contributes information, with no padding 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 tool with no output schema and no annotations, the description fully covers what the tool does, what it returns, how to invoke it with each parameter, and its caching behavior. It is self-contained and leaves no major 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 coverage is 100%, but the description adds value by explaining the distinction between brand_slug (auto-resolves real store domain) and url (explicit override), and notes that one is required. This goes beyond the schema's field descriptions, earning a 4.

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

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

The description clearly states the tool runs or fetches an Agent Readiness Report for a brand's own store website, with a specific verb and resource. It explicitly distinguishes this from the RRG page and ties the purpose to a marketing use case, making it distinct from sibling tools like get_brand.

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 states 'Use this to personalise partner outreach' and explains when to pass brand_slug versus url. It gives clear context for when to use the tool, but does not explicitly mention alternative tools or when not to use it, so it falls 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?

With no annotations provided, the description carries the full burden. It discloses the scope of data returned (profile, open briefs, purchasable listings) and the [BROWSE] prefix suggests a non-mutating read operation. While it doesn't mention auth requirements or error handling, for a simple get tool, the transparency is adequate.

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

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

The description is a single, compact sentence plus a short imperative instruction. It is front-loaded with the core purpose, includes no fluff or repetition, and every word 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?

The tool has only one parameter and no output schema, but the description covers the essential context: what the tool does, what data it returns, and where to get the input. It does not describe return structure or error cases, but for a narrowly-scoped get tool with good sibling context, it is sufficiently 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 100% (brand_slug is described with an example), so the baseline is 3. The description adds value by explaining how to obtain the parameter value: 'Provide a brand_slug from list_brands.' This contextual instruction goes beyond the schema's static description and helps the agent execute the correct workflow.

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

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

The description clearly states the tool's function: 'Get full details for a specific brand including its profile, open briefs, and purchasable listings.' It uses a specific verb ('Get') and resource ('brand details'), and distinguishes itself from sibling tools like list_brands by focusing on a single brand rather than listing all brands.

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 explicitly tells the agent how to use the tool: 'Provide a brand_slug from list_brands.' This gives clear context on the prerequisite step and the source of the parameter value. It doesn't mention when not to use it or alternatives, but the guidance is sufficient for a single-purpose 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context (deeper product browsing, live stock checks, sizing guides) and implies a read-only discovery operation via the [DISCOVER] prefix, but it does not explicitly state that the operation is non-mutating, nor does it mention any authentication requirements, error conditions, or response format. It is adequate but lacks rich behavioral detail.

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 compact and front-loaded: the first sentence immediately states the purpose, and the second sentence provides usage guidance. Every sentence earns its place with no filler or repetition.

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 tool is simple (one parameter, no output schema, no annotations). The description explains what the tool does, why to use it, and how it relates to the alternative get_brand. This is sufficient for an agent to select and invoke the tool correctly without needing additional detail about return values or error handling.

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%: the only parameter 'brand_slug' is already described with examples in the schema. The description adds no additional parameter-level detail beyond what the schema provides, so it meets the baseline for high schema coverage without needing to compensate.

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

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

The description clearly states the tool's function with a specific verb and resource: it retrieves a brand's dedicated per-brand MCP endpoint URL. It also explicitly distinguishes itself from the sibling tool get_brand, mentioning different use cases (deeper browsing vs. full profile).

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 provides explicit guidance on when to use this tool ('connect directly to a brand for richer interaction') and names the alternative ('use get_brand instead' for full profile with briefs and listings). This clearly signals the appropriate context and directs agents to the correct 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?

With no annotations provided, the description carries the full burden. It does disclose what the tool checks (status, credit balance, preferences, provider, operations remaining) but does not explicitly state that it is a read-only operation, how the two lookup parameters interact, or what the response structure looks like. This is partial disclosure—more than just the name but lacking important behavioral context.

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

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

A single concise sentence, front-loaded with a category tag, listing the key data points. No wasted words, all information is relevant, and the structure is easy to parse.

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 tool is simple (2 optional params, no output schema), but the description lacks an explicit return structure or conditions. It lists the categories of information but doesn't define what 'status' means or how the data is presented. While adequate for a basic getter, it leaves gaps that an agent might need to infer.

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

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

The input schema already documents both parameters with descriptions, including the fallback behavior for wallet_address when agent_id is omitted. The description adds no additional parameter meaning, so it does not justify raising above the baseline of 3, which is appropriate because schema coverage is 100% and the schema itself explains the relationship between the parameters.

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

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

The description clearly identifies the tool as a status checker for a Personal Shopper or Concierge, listing specific data points (credit balance, preferences, LLM provider, operations remaining). This differentiates it from sibling tools focused on agent standing, readiness, or points balance, and the verb 'check' combined with resource 'status of a Personal Shopper or Concierge' makes the purpose unmistakable.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or alternative tools such as get_my_preferences or get_points_balance, so an agent would need to infer usage from the name and the sibling list, which may lead to ambiguity.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the return value (brief ID) but does not explicitly state that the tool is read-only, has no side effects, or require any permissions. For a getter, this absence of safety context is a notable gap.

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

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

The description is a single, front-loaded sentence that efficiently communicates purpose, usage timing, return value, and optional filtering. No unnecessary words 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 simple getter with one optional parameter and no output schema, the description provides the essential context: when to call it, what it returns, and how to filter. It does not cover behavioral details, but those are largely addressed by the tool's simplicity and schema, keeping this dimension strong.

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 schema already describes brand_slug with 100% coverage, explaining it filters to a specific brand's current brief. The description adds only 'Optionally filter by brand_slug,' which does not introduce new semantic meaning beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function with a specific verb ('Get') and resource ('the current design brief'), and differentiates it from the sibling tool list_briefs by noting it returns the brief ID needed for submit_design. This makes the tool's purpose immediately obvious.

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 provides explicit usage context: 'Call this or list_briefs FIRST if you want to submit a design,' and notes the optional brand_slug filter. However, it does not specify conditions for choosing this tool over list_briefs beyond the 'current' versus listing all briefs, so it lacks full exclusion 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?

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states that attempts are capped per wallet and winner slots are limited, urging the agent to think before submitting. This goes beyond a simple getter and adds meaningful constraints, though it does not describe the return format or read-only nature explicitly.

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 concise and front-loaded with the core purpose ('Active VIA network quests for agents'), then efficiently explains quest mechanics, rewards, constraints, and the next step. Every sentence adds value without redundancy or unnecessary fluff.

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 provides rich context about quests, rewards, and the workflow, but it does not specify what the tool actually returns (e.g., a list of quests or a single quest), the structure of each quest object, or behavior when no quests are active. With no output schema, this omission leaves the agent uncertain about the result shape.

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

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

The tool has zero parameters, so the baseline is 4. The description adds no parameter-specific semantics, which is appropriate since there is nothing to document. The empty schema fully covers the parameter surface.

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 identifies the tool as providing active VIA network quests for agents, explaining that quests are knowledge challenges. The verb 'get' is implied from the name but not explicitly restated in the description, and the scope (active quests for agents) is clear. It distinguishes from siblings by referencing quest-specific tools like search_products and submit_quest_answer.

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 clear workflow guidance: use this to get quests, solve riddles with search_products, get_drop_details, and get_world_map, and answer with submit_quest_answer. It does not explicitly state when not to use it, but the contextual flow and mention of caps/winner slots imply careful usage.

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

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

With no annotations, the description carries the transparency burden. It correctly implies a read-only action ('Retrieve') and adds the prerequisite that the purchase must already have occurred. It does not disclose side effects (likely none) or error handling, but for this simple retrieval the context is adequate.

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 two short sentences, front-loaded with '[AFTER PURCHASE]' for immediate context, and every word adds value. There is no redundancy or 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?

For a simple two-parameter tool with no output schema or nested objects, the description fully covers what the tool does, when to use it, and how it relates to confirm_purchase. No critical information 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 input schema already describes both parameters with 100% coverage (e.g., 'Buyer wallet used at purchase' and 'Token ID of the purchased listing'). The tool description adds little beyond restating the purchase context, so the schema carries the explanatory weight, meriting the baseline score.

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

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

The description uses a specific verb 'Retrieve' and identifies the resource as 'signed download URLs for a previously purchased listing'. It also clearly distinguishes itself from sibling tools by mentioning confirm_purchase and the AFTER PURCHASE context, making its 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?

It gives explicit usage guidance: 'Use if you lost the original download link from confirm_purchase.' This tells the agent exactly when to invoke this tool versus alternatives, providing a clear decision 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?

With no annotations, the description must disclose behavior. It does so by enumerating return contents: 'metadata, physical product details, signed image URLs, on-chain supply status, and revenue split.' It clearly implies a read-only operation without side effects. Minor omissions like auth/error behavior are acceptable for such a simple read tool.

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

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

Three tightly packed sentences: purpose, return contents, and next-step guidance. No filler or redundancy, with the most critical information front-loaded.

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

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

For a one-parameter read tool without an output schema, the description is complete. It covers purpose, input context, return values, and workflow integration, leaving no important 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 coverage is 100% with tokenId described as 'Token ID of the listing'. The description adds the contextual detail that it is called after list_drops, but this does not add new parameter semantics beyond the schema. 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?

The description clearly states 'Get full details for a specific listing by tokenId' with a specific verb and resource. It distinguishes from sibling tools by positioning itself as the follow-up to list_drops, making its unique role explicit.

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?

Provides explicit when-to-use guidance: 'Call this after list_drops to see what you are buying' and 'Next step: call initiate_agent_purchase to buy this listing (AI agents must use this flow, not initiate_purchase).' This directly addresses usage context and alternatives, leaving no ambiguity.

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

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

No annotations are provided, so the description carries the full burden. It discloses the two distinct behaviors based on quest_slug presence, including the ordering logic ('in order'). It does not mention rate limits or pagination details, but for a read-only leaderboard query, this is adequate.

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 exactly two sentences, front-loaded with the tool's purpose, and every word adds value. It efficiently communicates the key functional split without waste.

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

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

Given the tool's relative simplicity and lack of output schema, the description is largely complete for a leaderboard retrieval. It covers both modes but doesn't specify the exact return format or error behavior. However, these are not critical for understanding the tool's core function.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantics for the quest_slug parameter by explaining the functional difference between providing it or not, which is not fully captured in the schema's description. The limit parameter is not further elaborated, but the overall semantic value lifts the score.

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

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

The description clearly identifies the tool as retrieving VIA Points leaderboards, with specific mention of two modes: overall points ranking without a quest_slug, and first correct solvers of a specific quest with a quest_slug. This is a specific verb+resource and distinguishes the tool's functionality from other 'get' tools 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 description explicitly explains when to use each parameter mode (with or without quest_slug), providing clear context for invocation. It does not explicitly mention when not to use the tool or name alternative tools, but given no direct sibling for leaderboards, the context is sufficient.

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

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

With no annotations provided, the description carries the burden for behavioral disclosure. It does add useful context: the handbook is the same for humans and AI agents, and identity is just a Base wallet. However, it does not mention whether the operation is read-only, requires any authentication beyond a wallet, or how the returned content is structured.

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 concise and front-loaded: it opens with the specific resource name, then adds three tightly scoped sentences covering naming, audience/identity, and contents. Every sentence earns its place without redundant or promotional language.

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 zero-parameter document retrieval tool, the description covers what the guide is, who can use it, and what it contains (strategies, talking points, commission structure, technical details). Since there is no output schema, this content description effectively sets expectations for the return value.

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

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

The tool has zero parameters, so the description cannot add parameter-level detail. The baseline for zero-parameter tools is 4, and the description adequately explains what the tool returns without needing parameter semantics.

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 the RRG Referral / Marketing / Affiliate Programme handbook'. It clearly states what the tool does and distinguishes it from sibling tools by focusing on the handbook content (strategies, talking points, commission structure, technical details) rather than other marketing actions.

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 provides useful context ('Works identically for humans and AI agents, identity is just a Base wallet') but does not explicitly state when to use this tool versus alternatives like join_marketing_program or create_ref_link. No exclusions or alternative tool references are given.

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

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

With no annotations, the description responsibly discloses that the tool returns a full snapshot of remembered data and emphasizes transparency ('you can see exactly what RRG remembers about you'). It does not discuss authentication or side effects, but as a simple read‐only view, the provided transparency is adequate.

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 just two sentences, front-loaded with a profile label, and every word adds value. It avoids repetition and is easy to parse quickly.

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

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

Given the tool's simplicity (one required parameter, no output schema), the description adequately outlines what kind of data is returned. It lacks an exact return format but is sufficiently complete for an agent to understand the tool's purpose and output.

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

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

The input schema already provides 100% coverage for both parameters (agent_wallet and query) with descriptive text. The description adds context about the returned contents but does not enhance parameter meaning, so a baseline score of 3 is appropriate.

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

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

The description opens with 'View your personalised agent profile on RRG', clearly stating the action (view) and resource (profile). It then enumerates specific data types (interaction history, purchase records, design submissions, brand preferences), which distinguishes it from sibling tools like check_my_commissions or get_points_balance.

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 makes the tool's purpose obvious, implying it should be used when an agent needs to see its RRG profile data. However, it does not explicitly mention alternative tools or when not to use it, so it falls short of full guidance but provides clear context.

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

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

With no annotations, the description carries the full burden. It says 'active' offers, implying a read-only operation, and provides useful domain context about voucher codes (RRG-XXXX-XXXX). But it does not mention pagination, rate limits, or explicit non-mutating guarantees. 'List' helps, but the description is not rich enough for a 4.

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 three sentences, front-loaded with the purpose, and carries no redundant phrasing. The [BROWSE] tag adds orientation. Every sentence contributes value.

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 list tool with one optional parameter and no output schema, the description fully explains what it returns (active voucher offers) and provides the redemption context. An agent can confidently decide when and how to invoke 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 schema description for brand_slug already covers the parameter purpose at 100% coverage. The tool description only restates 'Optionally filter by brand_slug' without adding syntax or format details. Baseline of 3 is appropriate.

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

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

The description opens with a clear verb+resource: 'List active voucher offers (perks) from brands.' It distinguishes itself from siblings like redeem_voucher by explicitly stating the redemption action elsewhere. The context about purchases and code formats clarifies the domain.

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 explicitly tells the agent to use redeem_voucher for redemption, naming a sibling tool as the next step. It also notes the optional brand_slug filter. However, it does not contrast with get_redemption_offers or list_brands, so the when-not guidance is incomplete.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavioral traits. It only states 'Your VIA Points balance' and explains points domain properties, but fails to explicitly state that this is a read-only operation, what the return format is, or any error handling behavior. The name 'get' implies read-only, but the description adds no transparency beyond that.

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 concise, with the main purpose front-loaded in the first sentence. The second sentence adds domain context about VIA Points that helps an agent understand the resource, though it could be considered non-essential. It is not verbose and every sentence provides some value.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is adequate but not complete. It explains what points are but does not mention the return type (e.g., numeric balance) or behavior for invalid wallets. Since this is a straightforward getter, the gaps are not critical, but additional specifics would improve completeness.

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

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

The input schema fully describes the only parameter agent_wallet with 'Agent wallet address on Base' and a regex pattern, so schema coverage is 100%. The description adds little extra meaning beyond the schema, only implying 'your' wallet, which is a marginal addition. The baseline score of 3 is appropriate.

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

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

The description clearly identifies the resource (VIA Points balance) and distinguishes it from sibling tools like check_agent_standing or get_agent_pass by using the specific term 'VIA Points balance' and 'cross-brand network loyalty balance'. However, it lacks an explicit verb like 'retrieves' or 'returns', making it slightly less direct than ideal.

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 provides contextual information about points (how they are earned, non-transferability) but gives no explicit guidance on when to use this tool versus alternatives such as redeem_points or get_redemption_offers. No exclusions or alternative recommendations are mentioned.

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

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

No annotations are present, so the description must carry the behavioral burden. It explains that offers are brand-published and each tier trades points for a voucher, which is meaningful context, but it does not disclose return format, authentication needs, or whether this is a safe read operation.

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 compact and front-loaded with the key purpose in the first phrase. It uses four short sentences with no wasted words, though the '[PLAY]' prefix and colloquial phrasing could be tightened.

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

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

Given the tool has only one optional parameter and no output schema, the description provides sufficient context: what the offers are, how they work, the filter option, and the redemption path. It could mention return shape or more detail about voucher mechanics, but overall it is complete enough for a straightforward read-only listing.

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 schema already documents brand_slug as 'Optional brand slug to filter offers' with 100% coverage. The description repeats this filter capability but adds no new semantic detail beyond the schema, so it meets the baseline without exceeding it.

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

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

The description clearly identifies the tool as retrieving brand-published redemption tiers that trade VIA Points for vouchers. This distinguishes it from sibling tools like get_offers by specifying the redemption-tier resource and its points-for-voucher nature.

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 when to use the tool: when exploring what VIA Points can buy. It also points to the related action 'Redeem with redeem_points', providing a clear next-step alternative, though it does not explicitly state 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?

No annotations are provided, so the description carries the full burden. It discloses that the tool returns status, title, and rejection reason if applicable, and implies a read-only operation. It does not mention auth requirements or rate limits, but for a status check the behavior is well enough explained.

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 two sentences and front-loaded with the core purpose. The '[CREATE]' prefix is dispensable and slightly confusing, but the rest is efficient and free of fluff. Loses one point for the irrelevant prefix.

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 tool is simple (one parameter, no output schema), and the description fully covers its context: when to call it, what it returns, and the possible statuses. The return values are explicitly described, which is essential since there is no output schema.

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

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

The input schema has 100% description coverage: the single parameter includes 'The submissionId returned by submit_design.' The description does not need to add additional parameter semantics. Baseline 3 is appropriate since schema fully handles it.

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

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

The description clearly states the tool's purpose: 'Check the status of a design submission.' It uses a specific verb ('Check') and resource ('design submission'), and distinguishes from siblings by focusing on design submission status. The '[CREATE]' prefix is odd but the core sentence 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?

Provides explicit when-to-use guidance: 'Call this after submit_design to find out if your submission was approved, rejected, or is still pending review.' It does not name alternatives or exclusions, but the context is clear enough for an agent to know when to invoke 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?

There are no annotations, so the description must bear the full burden of disclosing behavior. The description says eggs 'bank a small VIA Points reward' but does not clarify whether calling this tool triggers any side effects, or whether it is purely read-only. It also fails to explain the purpose of the required agent_wallet parameter, leaving the agent uncertain about potential effects or prerequisites.

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 four sentences and packs in multiple useful context points: location, content type, reward mechanism, and gating. It is front-loaded with the resource and location. A minor redundancy exists ('never products' could be inferred), but overall it is efficient and well-structured.

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

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

With no output schema and no annotations, the description must explain what the tool returns and why the wallet is needed. It fails to do so—there is no mention of the return format, whether it lists egg locations, or how the wallet factors in. The relationship with discover_egg is only implied. For a simple get tool, this is a significant 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 schema already provides complete coverage for the only parameter (agent_wallet) with a clear description and pattern. The tool description adds no additional meaning about how the wallet is used, so it does not improve upon the schema. Baseline of 3 is appropriate given high schema 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?

The description clearly identifies the resource (hidden easter eggs in /world) and distinguishes them from related tools like discover_egg by explaining the open vs. gated distinction. However, it does not explicitly state the operation (e.g., 'retrieves' or 'lists'), relying on the tool name 'get_world_eggs' to convey the verb. Overall, a clear purpose but with slight ambiguity about what the tool actually returns.

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 by noting that some eggs are gated and 'you answer with discover_egg,' suggesting when to use the sibling tool. However, it does not explicitly state when to call get_world_eggs itself (e.g., 'use this to view all eggs') or provide exclusions. The guidance is implied 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?

With no annotations, the description carries the full burden. It explains the semantics of the map (geography = meaning), the output structure, and the VIA quarter special case. It lacks an explicit statement about read-only behavior or potential response size, but as a parameterless GET tool, the described behavior is sufficiently transparent.

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 moderately lengthy but well-structured: it opens with the tool's purpose, explains the conceptual model, details return contents, introduces the VIA quarter, and closes with use cases. Each sentence contributes value, though it could potentially be tightened without loss.

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

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

Given the tool has no parameters and no output schema, the description fully covers what the tool returns, why it matters, and when to use it. It even includes a real-world URL for humans, making it self-contained for an agent to select and understand the tool 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?

The tool takes zero parameters, so the baseline is 4. The description adds context about what the returned map represents and how it relates to other tools, but there are no parameter semantics to clarify since none 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?

The description clearly states the tool returns a map of the RRG 3D world, specifying it as a spatial projection of product embedding space. It details the return contents (regions with label, centroid, product count) and distinguishes it from related tools like search_products and get_drop_details by referencing their matching world positions.

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?

Explicit usage guidance is provided: 'Use this to orient spatial queries... to describe where a listing sits in the catalogue, or to direct a human to a region of the world.' It also implicitly differentiates from siblings by noting that listings in search_products and get_drop_details carry a matching world position, suggesting this tool supplements those for spatial context.

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

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

With no annotations, the description provides the critical context that this tool returns payment instructions (payTo and amount) and that a manual USDC transfer is required before calling confirm_agent_purchase. However, it does not disclose whether calling the tool has side effects (e.g., reserving inventory, expiring instructions) or any auth/rate-limit constraints, leaving a transparency gap.

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

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

The description is three focused sentences: a purpose tag, a use condition, and a concise next-step workflow. Every sentence adds value, and the most critical information is front-loaded.

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

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

For a purchase initiation tool with no annotations and no output schema, the description covers the essential steps: getting instructions, paying USDC to payTo on Base mainnet, and confirming with a transaction hash. It still does not specify the response structure or any expiration/holding behavior, but the workflow is sufficiently complete for invocation.

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

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

The input schema already covers all parameters with detailed descriptions (100% coverage), so the description adds no new parameter-level detail. It does clarify the overall purchase flow but not the meaning of tokenId/buyerWallet beyond the schema, so the baseline score 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 opens with '[BUY, Agent Step 1]' and states 'Get payment instructions for a direct USDC transfer purchase,' clearly identifying the action and resource. It distinguishes from siblings by noting it is for agents that cannot sign EIP-712 permits, and references confirm_agent_purchase as the follow-up.

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 explicitly says 'Use this if you are an AI agent that cannot sign EIP-712 permits,' giving a clear condition. The follow-up instructions ('send exactly the specified USDC amount to payTo... then call confirm_agent_purchase') explain the workflow. However, it does not explicitly name an alternative tool (e.g., initiate_purchase) for permit-capable agents, so the when-not 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?

With no annotations provided, the description carries the behavioral disclosure burden. It reveals that the tool does not execute a purchase but returns a permit payload requiring EIP-712 signing, which is critical non-obvious behavior. However, it omits follow-up steps (e.g., whether a later confirmation call is needed) and details about permit expiry or side effects, leaving some ambiguity.

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 three concise sentences, front-loaded with the 'BUY, HUMAN WALLETS ONLY' label followed by clear instructions and audience specification. Every sentence contributes value 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?

The description is complete enough for its intended human-wallet audience: it states what is returned (EIP-712 permit payload) and who should use it, while actively diverting AI agents to the correct sibling tool. It does not fully describe the end-to-end flow (no mention of confirm_purchase or what happens post-signing), but the absence of an output schema makes the return-value disclosure somewhat basic.

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

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

Schema description coverage is 100%, so the baseline of 3 applies. The tool description itself adds no parameter-specific meaning, but the schema already documents all parameters thoroughly, including size/color nuances and requirements for specific listing types.

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

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

The description clearly states the tool's function: it returns an EIP-712 permit payload to be signed, with a 'BUY' label and explicit human-wallet-only scope. It also distinguishes itself from the sibling initiate_agent_purchase by directly stating which tool AI agents should use instead.

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 provides explicit usage guidance: AI agents must NOT use this tool and should use initiate_agent_purchase instead, while human wallet apps (browser/hardware) should use it. This clearly communicates when to use vs. alternatives.

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

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

With no annotations provided, the description fully covers the behavioral profile: it explains the commission structure (10% on platform's share), identity mechanism (Base wallet), what you receive (unique partner ID), and the immediate ability to refer. It also states requirements upfront, making the tool's side effects and post-conditions clear.

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 well-structured with a clarifying header, broken into logical chunks: what the tool does, commission details, what happens upon registration, and requirements. Every sentence adds value without redundancy or fluff, making it dense but easily scannable.

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 registration tool with no output schema, the description is remarkably complete. It explains the programme's purpose, earning potential, identity rules, the resulting partner ID, and the next step (log_referral). It also clarifies the requirement of a Base wallet, leaving little ambiguity for an agent deciding to call this 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% (all three parameters have descriptions), so baseline is 3. The description adds minimal extra semantics beyond the schema: it repeats the wallet purpose and mentions the optional ERC-8004 agent ID, but the schema already covers these. No additional parameter-specific meaning is provided.

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

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

The description clearly states the tool's function: 'Register as an RRG referral partner / marketing partner / affiliate.' It uses a specific verb ('register') and resource, and explicitly distinguishes this as 'THE single programme' for earning commission, differentiating it from siblings like create_ref_link or get_marketing_handbook.

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 provides explicit when-to-use guidance, positioning this as the mandatory entry point for anyone earning commission by referring agents, and notes that after registration you can 'start referring other agents immediately via `log_referral`.' It also clarifies that the same programme applies to humans and AI agents, removing ambiguity.

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

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

With no annotations, the description transparently indicates this is an informational retrieval ('Get the invite link and channel directory') rather than a state-changing join operation, despite the tool name. It doesn't cover auth or rate limits, but for a zero-param getter this is adequate.

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, first is action-oriented and front-loaded, second provides context. No wasted words.

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 tool's simplicity (0 params, no output schema) means the description fully covers its purpose and context; 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?

No parameters exist, and schema coverage is 100% (empty schema), so there is nothing for the description to add; the baseline for 0 params is 4.

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 the verb 'Get' with a specific resource ('RRG Discord invite link and channel directory'), clearly distinguishing this tool from the 45 siblings, none of which cover Discord access.

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

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

It implies usage by explaining the Discord's role as a hub for agent networking and alerts, which gives clear context for when to invoke it. Though it doesn't explicitly mention alternatives, the uniqueness of the tool makes this context sufficient.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It reveals that results are in chronological order, lists the exact fields returned, and specifies the ISO 8601 format of createdAt. It does not mention pagination, rate limits, or authentication requirements, but for a simple read-only list, this is adequate. The '[BROWSE]' tag further signals a safe, non-mutating operation.

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

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

The description is a compact three-sentence paragraph that front-loads the purpose with '[BROWSE]'. Each sentence earns its place: purpose and scope, return fields and date format, and sorting/usage guidance. There is zero fluff or repetition.

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 list tool with no output schema, the description explains the return fields and ordering, which is essential. It also connects to sibling tools for filtering. It does not mention pagination or result limits, which could be relevant, but for a browse-all operation the given context is largely 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?

The tool has zero parameters, and the schema covers 100% of them (vacuously). The description does not need to explain parameter meanings because there are none. The baseline for 0 params is 4, and the description adds no conflicting or redundant parameter 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?

The description clearly states the verb 'List' and the resource 'all active brands' on the platform. It distinguishes itself from siblings like get_brand (single brand) and list_drops/list_briefs (different resources) by explicitly mentioning how to use a brand slug with the latter tools. The scope is precise: 'active brands'.

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 provides clear context for browsing all brands and notes that sorting by createdAt descending reveals recently added brands. It also tells the user to use list_drops or list_briefs with a brand slug to filter by brand, which is an alternative usage. However, it does not explicitly state when to use get_brand or register_brand, though the browsing intent 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?

With no annotations, the description carries the full burden of behavioral disclosure. It clearly indicates a read-only browse operation, enumerates return fields ('brief title, brand name, description, and brief ID'), and clarifies the exclusion of products for sale. It does not mention pagination or error conditions, but for a simple listing tool this is sufficient.

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 concise and well-structured, starting with the core purpose and moving through exclusions, usage triggers, return values, and cross-tool instructions. Every sentence earns its place, making it easy to scan quickly.

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 list tool with one optional parameter and no output schema, the description is complete. It explains what the tool lists, what it does not list, when to call it, what it returns, and how to use the result with submit_design. No critical information is missing for an agent to select and invoke the tool 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?

The input schema has 100% coverage for the sole parameter brand_slug, so the schema already documents it. The description does not add any extra semantic meaning about the parameter itself. The cross-reference to submit_design concerns the output, not the input, so the description adds no parameter-level value 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?

The description uses a specific verb and resource: 'List open design briefs, creative challenges and collaboration requests'. It clearly distinguishes from siblings by stating 'These are NOT products for sale' and referencing list_drops as the alternative for products. This makes the tool's purpose unambiguous and distinct from list_brands and list_drops.

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?

Explicit guidance is provided: 'Call this when asked about briefs, collaborations, creative challenges, or what brands are looking for.' It also names an alternative: 'To see products for sale, use list_drops instead.' Additionally, it instructs how to use the output: 'Use a brief ID with submit_design to respond.' This fully covers when and how to use the 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?

With no annotations, the description carries full burden and does so excellently. It discloses pagination behavior, response structure, cost of paging thousands of items, and what is NOT included (live on-chain minted count), guiding the agent to get_drop_details.

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?

Each sentence serves a distinct purpose: purpose, usage guidance, alternative, return format, field details, exclusions, and next steps. Dense but not verbose, front-loaded with the primary action.

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 lacking an output schema, the description thoroughly explains the return format and fields, making the tool self-contained. It also places the tool in a broader workflow (narrowing down then get_drop_details + initiate_agent_purchase), which is sufficient for an AI agent.

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. The description adds minimal extra semantics beyond the schema, mainly reinforcing pagination with next_offset but not detailing parameter formats or constraints beyond what the schema already provides.

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

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

The description clearly states 'List active RRG listings, paginated, optionally scoped by brand_slug.' This provides a specific verb (List), resource (active RRG listings), and scope (brand_slug), distinguishing it from search_products and get_drop_details.

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

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

Explicitly states when to use this tool ('when exploring the catalogue without a specific item in mind') and when to use an alternative ('if you already have a product name... call search_products FIRST'), including a cost rationale. Also gives next-step 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?

With no annotations provided, the description carries the full burden. It discloses the prerequisite and the reward mechanism, but it does not specify side effects, whether the operation is idempotent, or what happens on failure (e.g., if the same referral is logged twice). The description adds context beyond the schema but lacks important behavioral details for a mutation.

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 three sentences, each adding value: category label, action, benefit, and prerequisite. It is front-loaded and avoids redundancy. Every sentence earns its place.

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

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

The description covers the tool's role in the referral program, the prerequisite, and the earning mechanism. It also clarifies that referrals can be agents or humans. It lacks details on return values or duplicate handling, but given the simple parameter schema and no output schema, it is sufficiently complete for an agent to use 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?

The schema has 100% coverage with all 5 parameters described. The description does not add parameter-specific semantics beyond what the schema already provides; it only gives overall context. This meets the baseline for high schema 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?

The description clearly states the action: 'Log a referral, register an agent (or human) you have recruited to RRG.' It uses a specific verb and resource, and the benefit (earning 10%) further clarifies the purpose. It also distinguishes from sibling tools like create_ref_link and join_marketing_program by focusing on the logging action.

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 provides a clear prerequisite: 'You must be a registered partner (use join_marketing_program first).' It also implies when to use this tool (after recruiting someone) and describes the outcome (earning commission on first action). While it doesn't explicitly contrast with alternatives, the context is sufficient for an agent to decide.

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

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

With no annotations, the description carries the full burden. It discloses the EIP-191 signature requirement and 5-minute replay window, offering critical security context. It also implies external side effects by noting posts go to public channels, adding value beyond the 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?

The description is concise and well-structured: the first sentence states the purpose, followed by auth requirements and call instructions. Every sentence earns its place 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 post-broadcast tool with no output schema and no annotations, the description covers the essential behavior, auth, security, and signing details. It omits explicit return/error handling but is sufficiently complete given the tool's straightforward nature.

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 already covers all 5 parameters (100% coverage), so baseline is 3. The description adds a specific signing format ('sign RRG-PRISCILLA-POST:<sha256(content)>:<timestamp>'), clarifying how signature and timestamp relate, and notes the RRG signoff auto-appended, enriching the parameter understanding.

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 an explicit action and target: 'Broadcast a marketing post to RRG public channels (Telegram, BlueSky, Discord)'. The bracketed '[PRISCILLA ONLY]' and reference to the autopost path clearly distinguish it from sibling marketing tools.

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

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

Provides clear context for use: broadcasting marketing posts to specific public channels, restricted to Priscilla. It mentions the auth flow and replay window but does not explicitly name alternative tools or state when not to use this tool, stopping 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?

With no annotations, the description carries the full burden. It discloses the one-time voucher issuance and the restriction on provisional points, adding useful behavioral context. However, it omits critical side effects like the irreversible nature of point spending or any authorization requirements, leaving gaps.

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

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

The description is three concise sentences with no filler, front-loaded with the primary action. Every sentence adds value, covering purpose, source, outcome, and a 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 simple tool with 2 parameters and no output schema, the description covers the prerequisite (get_redemption_offers), the action, and the output (voucher code). It lacks error handling and cancellation details but is sufficient for an agent to select and invoke the tool 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% for both parameters, so the baseline is 3. The description adds a helpful pointer that tier_id comes from get_redemption_offers, but this is minor and does not significantly enhance understanding 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?

The description names the specific verb 'spend', the resource 'VIA Points', and the object 'redemption tier', clearly distinguishing this from siblings like get_redemption_offers and redeem_voucher. It also states the outcome (one-time RRG voucher code), making the tool's function 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 description references get_redemption_offers as the source of tier_id, implying a prerequisite workflow. However, it does not explicitly name alternative tools or provide exclusion criteria (e.g., when not to use this vs redeem_voucher), so it falls short of full 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?

With no annotations, the description carries the full burden. It discloses the key behavioral outcomes: 'Redeeming links you and your human into one VIA network member and banks the reward to the pair.' This goes beyond just saying 'redeem' and explains the post-conditions. It does not cover error states or prerequisites, but the main effects are clear.

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 three concise sentences, front-loaded with the main action, followed by essential context and outcome. Every sentence delivers value without redundancy or excessive 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?

The description provides sufficient context for a simple redeem action: the source of the code, the two-player rule, the required agent wallet (implicitly), and the reward effect. It lacks explicit error handling or response details, but these are not essential given the tool's simplicity and the lack of an output schema.

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

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

The schema description coverage is 100%, with both parameters already well-documented (code format, agent_wallet pattern and purpose). The description does not add additional semantics beyond what the schema provides, which is the baseline expectation for high 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?

The description clearly states the tool's function: 'Redeem a cipher code (VIA-XXXX-XXXX) your human found in the 3D world at /world.' It specifies the action, the resource, and the unique context of cipher quests, distinguishing it from sibling tools like submit_quest_answer or discover_egg.

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 the two-player nature: 'the human walks the trail, their OWN agent redeems the code.' This provides clear context on when to use the tool (for cipher quests) and the responsibility of the agent. However, it does not explicitly mention when not to use it or name alternative 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?

No annotations are provided, so the description carries the burden of transparency. It discloses that each voucher can only be redeemed once and mentions the return value (voucher details and URL). This is useful, though it does not detail any state changes or permission requirements.

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 two sentences, front-loaded with '[AFTER PURCHASE]', and contains no redundant information. Every phrase adds value.

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

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

Given the simple tool (2 params, no output schema, no annotations), the description covers purpose, context, behavioral constraint, and return value. It is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds the voucher code format and the single-use constraint, but it does not add significant meaning beyond the schema's own 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 description clearly states the tool redeems a voucher code, specifies the format (RRG-XXXX-XXXX), and sets context with '[AFTER PURCHASE]'. This distinguishes it from sibling tools like redeem_points and redeem_quest_cipher which target different resources.

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 indicates the tool should be used after purchasing a drop, providing clear contextual guidance. However, it does not explicitly name alternative tools or provide exclusionary guidance (e.g., 'use redeem_points for point redemption').

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

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

With no annotations provided, the description carries the full burden. It discloses the pending approval status, 24-hour review window, post-approval benefits, and the requirement that accept_terms must be true. It doesn't cover failure modes or whether registration can be modified, but the core approval flow is well communicated.

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 well-organized with a clear opening, bulleted benefits, and a status/requirements section. It's moderately sized but every part adds useful context; the 'Requires' line duplicates the schema's required list but serves as a quick checklist.

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 registration tool with a rich schema and no output schema, the description covers the workflow, approval timeline, and expected outcomes. It doesn't specify the response format, but the pending-approval status provides sufficient closure for normal usage.

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?

Input schema coverage is 100%, so the baseline of 3 applies. The description reinforces key requirements (accept_terms must be true, wallet_address is for USDC) but adds little beyond the schema, which already explains each field in detail.

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

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

The description clearly states the action ('Register your own brand on RRG') and differentiates this creation tool from sibling read tools like get_brand and list_brands. It also frames it as the mechanism for AI agents to launch a brand, making the intent unmistakable.

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

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

The description gives strong context: it explains this is how agents launch their own brand, lists prerequisites, and describes what happens after approval. It doesn't explicitly state when not to use it or name alternative tools, but the creation-vs-management distinction is clear from the sibling list.

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

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

With no annotations, description fully discloses behavior: rejection status on vague queries, indexed fields, match ranking, returned fields, size auto-extraction and exact-price guidance, and variantSummary semantics. Provides exact pricing priority and notes unavailable variants are still returned.

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?

Long but front-loaded with '[FIND] START HERE'. Every sentence carries unique operational guidance: rejection behavior, query patterns, ranking, size handling, pricing precision, next-step calls, and zero-match fallbacks. Structure uses clear sections and actionable 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?

For a 4-param tool with no annotations and no output schema, the description is exceptionally complete. It covers purpose, alternative tools, parameter semantics, return payload contents, size-variant behavior, failure handling, and follow-up actions. No critical 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 coverage is 100% but description adds substantial meaning: query pattern types (SKU dash/space insensitive, brand+category, collaborator), multi-token independent matching, size parameter behavior vs. auto-extraction, and brand_slug source via list_brands. This far exceeds schema 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?

Description states a specific verb and resource: 'Free-text search across every active RRG listing.' It clearly distinguishes itself from sibling tools by contrasting with list_drops for browsing without intent and get_drop_details for optional detail augmentation.

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 tells when to use: 'START HERE when you know what you want.' Gives exclusions: generic browse words are rejected with needs_more_detail. Names alternatives: 'To browse without intent, call list_drops instead' and describes next-step tool calls.

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

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

No annotations are provided, so the description carries the full burden. It discloses that approved designs become ERC-1155 NFT listings with 35% royalty to the creator, and requires accept_terms=true. It also details the email submission fallback process, but doesn't mention whether the submission is irreversible or any review timeline, leaving some behavioral gaps.

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

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

The description is well-structured with clear sections and front-loads the action and prerequisite. It's somewhat verbose due to the detailed email fallback, but each part serves a purpose, making it appropriately sized.

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 action, workflow order, and required versus recommended fields. It also explains the fallback pathway for image delivery, making it largely complete for the agent to invoke correctly, though it lacks explicit success response details.

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

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

Schema description coverage is 100%, so the baseline is 3. The description mostly repeats schema details (e.g., max 5MB, title ≤60 chars) but adds workflow context like needing a brief_id from list_briefs and the upload_image step. This is marginal added value 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?

The description clearly states 'Submit an original artwork for review' with a specific verb and resource. It also distinguishes itself from siblings by framing this as '[CREATE, Step 2]' and referencing list_briefs/get_current_brief, making it distinct from upload_image or submit_quest_answer.

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 explicitly instructs to call list_briefs or get_current_brief first, and to use upload_image first if the image is generated locally. It also provides an email fallback for when images cannot be delivered via MCP, giving clear when-to-use guidance and alternatives.

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

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

With no annotations provided, the description carries the full burden. It discloses two key behaviors: attempt limits per wallet and the reward of VIA Points. This is valuable context, though it does not detail failure modes or what happens on incorrect submissions.

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 two sentences, front-loaded with the action, and every sentence adds value. No wasted words or repetition.

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-parameter submit tool with no output schema and no annotations, the description is quite complete: it explains the action, the reward, and a critical constraint. It could mention how to check submission status, but the sibling tool implies that path.

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

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

The input schema covers all three parameters with descriptions, and the schema coverage is 100%. The tool description adds no additional parameter-specific semantics beyond what the schema already provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Submit an answer to an active quest riddle.' It uses a specific verb and resource, and distinguishes itself from siblings by focusing on submission and the VIA Points reward.

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 provides clear usage context by warning that attempts are capped per wallet and advising to verify reasoning against the catalogue first. While it does not explicitly mention alternatives, the guidance implies when to use this tool and when to hold off.

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

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

With no annotations provided, the description carries the full burden. It discloses the three input methods, chunk concatenation behavior, size limits, and return structure. It also notes the possibility of truncation and suggests an email workaround. However, it doesn't mention error handling, validation, or side effects beyond hosting, so a 4 is warranted.

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 longer than average due to the alternative email path, but it is well-structured with clear sections and line breaks. Every sentence provides operational value, and the return format is explicitly shown. It could be trimmed slightly, but the organization and formatting earn it a 4.

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

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

Given that there is no output schema, the description fully explains the return value ({ image_id, image_url, format, size_bytes }) and how to use it with submit_design. It also provides a fallback method for edge cases, making the tool description self-contained. This is rare and highly 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 100%, so baseline is 3. The description adds value by explaining each parameter beyond the schema: data URI prefix allowance, max 5 MB for image_url, and when to use image_chunks ('if your base64 string is too large'). This extra guidance helps the agent select the correct input method.

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: 'Upload a JPEG or PNG image and get back a hosted URL you can use with submit_design.' This clearly states the tool's function and its relationship to a sibling tool, distinguishing it from other tools. The purpose is unambiguous and action-oriented.

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 explicitly states when to use this tool ('when your agent framework produces images as artifacts') and provides a direct alternative (email submission) with specific conditions ('If your runtime truncates large base64 strings'). It also instructs how to use the result with submit_design, offering clear usage context and exclusions.

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

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

With no annotations, the description carries the burden of explaining side effects and context. It discloses the credit effect, the prerequisite transfer, and the conversion rate. It does not mention failure modes or idempotency, but the core behavior is transparent.

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 two sentences, front-loaded with the purpose, and includes essential operational details (wallet address, sequence, conversion rate) without any 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?

The description gives a complete workflow for a straightforward financial tool: where to send funds, how to invoke, and what will happen. It lacks only minor caveats like minimum amounts or return value expectations, but the core context is 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 coverage is 100%, with both parameters described (tx_hash as the transfer hash, agent_id as the Concierge identifier). The description adds minimal parameter-specific detail beyond the schema, only implicitly referencing the transaction hash.

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

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

The description clearly states the tool verifies a USDC transfer and credits the equivalent USD to a Concierge. It includes specific details like the wallet address and conversion rate, making it distinct from all sibling tools.

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

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

The description explicitly sequences the usage: send USDC first, then call with the transaction hash. It also specifies the exact wallet address and conversion rate, but does not mention when not to use it or alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the on-chain registry check and the badge assignment, and explicitly states optionality. However, it does not mention whether the action is read-only or has permanent effects, nor any error conditions or auth requirements. Moderate transparency.

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

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

The description is a well-organized paragraph with a clear lead-in ('[TRUST] Verify...'). It includes a registration URL and a reassurance about optionality, both useful. Every sentence earns its place, though slightly longer than strictly necessary. Structure is effective.

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

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

Given no output schema, the description does not explain what the tool returns (e.g., success message, badge status, error if not registered). It describes the action and optionality but lacks return-value context and potential edge cases. For a simple tool, it is mostly complete but has notable 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?

The schema covers the single parameter 'agent_wallet' with a clear description and regex pattern (100% coverage). The tool description adds context about the registry and registration link but no additional parameter semantics. Baseline 3 is appropriate since the schema does the heavy lifting.

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

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

The description clearly states the verb 'Verify' and the resource (World AgentKit / AgentBook registry), and explains the outcome (World ID trust badge). It is distinct from sibling tools like check_agent_standing, though it doesn't explicitly name alternatives. This is clear but not fully differentiated from potential similar verification tools.

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

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

The description notes it is optional and that unverified agents can still use the platform, which gives partial usage guidance. However, it doesn't specify when to choose this over other verification or standing tools, nor does it state prerequisites beyond registration. Implied usage but no explicit alternatives.

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