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 provided, the description carries the full burden and delivers comprehensively: it enumerates the complete side-effect pipeline ('verifies your on-chain USDC transfer, mints your ERC-1155 NFT, fires ERC-8004 reputation signals for both buyer and seller, distributes revenue to creator and brand') plus the download URL return. Disclosing that reputation signals fire for both parties and that revenue gets distributed is exactly the non-obvious behavioral context an agent needs before invoking a payment-claiming 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?

Front-loaded with a one-line summary and call trigger, then a tight side-effect list, then conditional field requirements. Roughly 150 words for a 16-parameter, no-annotation purchase tool, and every sentence earns its place: flow position, side effects, optional-param rationale, physical-goods requirements, and field rationale. No fluff or repetition of what the schema already says.

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

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

For a high-complexity tool (16 params, no annotations, no output schema), the description covers flow position, non-obvious on-chain side effects, the return value ('returns your download URL'), conditional required-field bundles, and rationale for optional parameters. Only error-condition behavior (e.g., invalid txHash or insufficient USDC) is omitted, which is minor given how much is disclosed.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds genuine value: it groups the eight physical-product fields into one conditional bundle rather than leaving the agent to infer them from scattered 'required for physical products' notes, provides rationale (shipping_phone 'required for delivery confirmation', buyerEmail 'so the buyer receives their order confirmation'), and explains the purpose of optional buyerAgentId as an agent-to-agent trust signal. This raises it above baseline without duplicating schema text.

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

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

The description opens with a specific verb+resource ('Confirm your USDC payment and claim the listing') and anchors the tool in its flow position ('[BUY, Agent Step 2]', 'Call after sending USDC to the address returned by initiate_agent_purchase'). It clearly distinguishes itself from the initiate step and, through repeated ERC-8004/agent framing, from the sibling 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?

Explicitly states the triggering precondition ('Call after sending USDC to the address returned by initiate_agent_purchase') and the full effect sequence the call performs. It adds conditional guidance for physical products ('For physical products you MUST include...') and optional guidance for buyerAgentId, but never explicitly names the when-not case (e.g., using confirm_purchase for non-agent purchases), so it stops short of a 5.

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

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

With no annotations provided, the description carries the full burden and discloses key behaviors: mints an NFT on-chain, gasless (platform covers gas), returns a download link, and includes revenue split details. It does not mention irreversibility or failure modes, but it covers the main side effects and prerequisites well.

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 appropriately sized and front-loaded with the main purpose. Each sentence adds useful context (physical requirements, phone/email rationale, revenue split). It is not overly verbose, and the structure with '[BUY, Step 2]' provides immediate orientation.

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 (16 params, no output schema), the description covers the essential context: the prerequisite permit, gasless minting, return value (download link), revenue split, and the critical distinction between physical and digital products. It does not explain every optional parameter, but the schema already does that, so the description 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 the baseline is 3. The description adds value beyond the schema by explicitly listing the required physical-product shipping fields, explaining why shipping_phone and buyerEmail are required, and noting that ref_code does not change the price. This helps the agent select and validate parameters correctly.

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

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

The description states a specific verb ('Complete the purchase', 'Mints the ERC-1155 NFT') with a clear resource and workflow step ('[BUY, Step 2]'). It explicitly references initiate_purchase as the prerequisite, distinguishing it from the sibling confirm_agent_purchase and making its role 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 clearly indicates this is the second step after initiate_purchase and provides explicit conditions for physical products ('you MUST include...'). However, it does not explicitly mention when NOT to use this tool (e.g., for agent purchases use confirm_agent_purchase), so it lacks an explicit exclusion statement.

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, and it fully delivers: it states the tool affects nothing, that it historically caused a problematic split identity, and that every call now returns the VIA onboarding URL. This is exemplary transparency about the tool's retired, side-effect-free behavior.

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

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

The description is multi-sentence but every sentence earns its place: retirement status, where accounts are now created, why the old behavior was harmful, and what the tool currently returns. It is dense with necessary context and contains 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?

Despite 11 parameters and no output schema, the description is complete: it explains the tool's actual current behavior, return value type, and the correct owner action. No additional behavioral or usage information is missing for an agent to use this 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 schema has 100% parameter coverage and rich descriptions, so the baseline is 3. The description adds important context that all parameters are effectively irrelevant because the tool no longer creates anything and always returns the same URL, preventing an agent from over-weighting parameter choices.

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 immediately states the tool is retired and no longer creates anything, then clearly defines its current function: every call returns the VIA onboarding URL to send the owner to. It is specific about the resource (VIA onboarding URL) and distinguishes this from the historical behavior implied by the tool name.

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 clearly explains that account creation now happens on VIA, not through this tool, and instructs the agent to 'Send the owner there.' This is strong usage guidance, though it does not explicitly name a sibling MCP tool as an alternative; the alternative is an external platform URL.

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, and it does well: it explains the commission payment timeline ('paid in USDC to your wallet when the sale settles'), the returned artifacts (short link and ref_code), and explicitly states 'no approval needed'. It does not mention rate limits or edge cases, but for a simple creation tool, this is transparent enough.

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 long, front-loaded with the core purpose, and every sentence is informative. It avoids redundancy and fluff, containing only necessary details about the tool's function, output, and usage.

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 two parameters, no output schema, and no annotations, the description covers everything needed: what the tool creates, how the commission works, the format of the returned link, and how to use the ref_code. It is complete and self-contained.

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 descriptions already explaining both parameters, so the baseline is 3. The description adds extra semantics by elaborating on `partner_wallet` ('Your Base wallet; commission is paid here') and how the output `ref_code` links to other tools, which goes 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 opens with a specific action: 'Create a product referral link' for affiliate commission, which clearly states the tool's function and sets it apart from sibling purchase/quest tools. It elaborates on the purpose: earning commission via USDC, 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?

It provides clear use-case context: 'Open to any wallet, no approval needed' removes prerequisites, and 'Share the link, or pass ref_code to buy_product / confirm_purchase' tells how to apply the output. It does not explicitly name alternatives or exclusions, but the tool is the only likely method for creating referral links; still, it gives enough guidance for when 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 provided, the description carries the full burden. It discloses that the first discovery banks a reward to the wallet, returns a video URL, and that gated eggs require an answer while open eggs do not. It also clarifies no purchase is involved. This goes beyond a basic 'discovers egg' statement, though it does not cover failure cases or repeated-discovery behavior.

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

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

The description is three sentences, each earning its place: what the tool does, how gating works, and the reward/return. It is front-loaded with the action and uses 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?

For a tool with 3 parameters and no output schema, the description covers the return value (video URL), reward condition, gated/open behavior, and the non-commercial nature. It does not describe error handling or preconditions (e.g., must have an egg from get_world_eggs), but overall it provides enough context to use 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 already covers all 3 parameters with descriptions at 100% coverage. The description adds context by linking the 'answer' parameter to gated eggs and referencing get_world_eggs for egg_slug, but this adds minimal new meaning beyond the schema. Baseline 3 applies as 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 uses a specific action verb 'Discover' and a concrete resource 'an easter egg from get_world_eggs', clarifying that it reveals the egg's film. It distinctly separates gated vs open eggs and notes 'Eggs are content, not listings: there is nothing to buy', clearly distinguishing this from purchase or listing 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 states when to use it ('For a gated egg, pass your answer to the challenge; open eggs need none') and references get_world_eggs as the source of egg_slug, implying a workflow. It lacks an explicit 'use instead of' alternative but gives sufficient context for choosing this 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 the full burden of behavioral disclosure. It reveals key traits: the cost ($0.10 USDC), what the user gets (credits, priority access), limits (500 passes, max 5 per wallet), and the return value (payment instructions). It also outlines the subsequent action (send USDC, then confirm). This goes beyond the minimum by explaining the full process, though it does not detail the exact structure of the payment instructions.

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 an introductory sentence, bullet points for benefits, and a closing note on next steps. It is slightly longer than strictly necessary but every sentence contributes value, and the bullet list improves scannability. It is not as tight as the two-sentence TDQS example, but it remains efficient.

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 one parameter and no output schema, the description is thorough. It explains the membership costs, benefits, limitations, and the complete purchase flow (get instructions, send USDC, confirm). This is sufficient for an agent to understand how to call the tool and what to expect. It does not cover edge cases like refunds or failure modes, but those are not essential given the simple nature of the 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?

The input schema has 100% coverage for the single parameter buyerWallet, so the schema already documents its format and purpose. The description adds a limit (max 5 per wallet) but that is a business constraint, not a parameter semantic detail. Therefore, the description adds little beyond the schema, warranting the baseline score of 3.

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

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

The description clearly states the tool's purpose: obtaining the RRG Agent Pass Phase 1 founding membership. It specifies the action ('Get your RRG Agent Pass') and distinguishes itself from sibling tools by detailing the exact next step ('call confirm_agent_purchase with your txHash'). This is a specific verb+resource with differentiation from related 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 clear context on when to use the tool (to start the membership purchase flow) and explicitly names the follow-up tool (confirm_agent_purchase). It also includes conditions like 'Max 5 per wallet' and 'Limited to 500 passes', which help the agent understand eligibility. However, it does not explicitly state when not to use it or mention alternative tools like initiate_agent_purchase, so it stops short of a 5.

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

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

With no annotations provided, the description carries full responsibility. It candidly discloses caching behavior ('Results cache for 24h'), the ability to fetch a cached report or run a new one, and clarifies the scope (own store, NOT RRG page). This goes well beyond a basic description.

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 long, front-loaded with the core purpose. It covers action, scope, outputs, usage, and caching without any redundancy. Every sentence is informative and earns its place.

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

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

For a simple 2-parameter read-only tool with no output schema, the description fully covers the purpose, inputs, expected outputs, caching behavior, and a concrete use case. 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?

Schema coverage is 100%, so the baseline is 3. The description adds semantic value by explaining the distinction between brand_slug (auto-resolves the real store domain) and url (explicit, for brands not on RRG). This reinforces and enriches the schema 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 verb and resource: 'Run (or fetch the cached) Agent Readiness Report' for a brand's OWN store website. It distinguishes from RRG pages and specifies the exact outputs (score, percentage, band, shareable URL, failing checks), making the tool's 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 gives an explicit use case: 'Use this to personalise partner outreach.' It also guides parameter selection ('pass a brand_slug to auto-resolve... or pass an explicit url'). However, it does not mention when not to use the tool or name alternative sibling tools, 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?

No annotations are provided, so the description carries the full burden of explaining behavior. It does not disclose whether this is a read-only operation, potential errors (e.g., invalid slug), authentication requirements, or how the returned data is structured. The [BROWSE] hint is not an explicit behavioral guarantee.

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, well-structured sentence that immediately conveys the tool's purpose and the required parameter. It is front-loaded with actionable information and contains 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?

While the tool has only one parameter and is a simple lookup, the description does not cover error handling, authentication, or output shape. It lists the main content areas, which is helpful, but given no output schema or annotations, a more complete description would note potential failure modes and prerequisites.

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 a clear description and example for brand_slug. The description adds value by explaining that the slug should come from list_brands, offering guidance on how to find a valid value. The high schema coverage means the parameter is well understood without further 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 it retrieves full details for a specific brand, listing the included categories (profile, open briefs, purchasable listings). This distinguishes it from sibling tools like list_brands, which presumably lists brands rather than details for one.

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

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

It provides context for usage by instructing to supply a brand_slug from list_brands, implying a prerequisite step. However, it does not explicitly state when to choose this tool over alternatives or mention any 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?

No annotations are provided, so the description carries the burden. It discloses that the tool returns a connection URL and describes the capabilities enabled by that endpoint (live stock, sizing guides). The 'Get' verb implies a read-only operation, and the [DISCOVER] tag hints at a non-destructive discovery action, though it does not explicitly state 'read-only' or mention potential edge cases like missing endpoints.

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 a [DISCOVER] tag and a clear subject. Every sentence contributes meaning: the first defines the tool's output and value, the second contrasts with a sibling tool. No filler or redundancy.

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

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

There is no output schema, so the description must indicate what is returned. It does: 'MCP endpoint URL'. It also explains the practical uses of that URL. It omits potential error conditions (e.g., brand not having an endpoint) and does not specify the exact URL format, but for a single-parameter discovery tool, the provided context is largely 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?

The schema provides 100% coverage for the single parameter 'brand_slug', including an example. The description does not add extra parameter-level detail, but the schema fully documents the parameter, 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 specific function: 'Get a brand's dedicated per-brand MCP endpoint URL' and enumerates its uses (deeper product browsing, live stock checks, sizing guides). It also distinguishes from the sibling 'get_brand' by pointing to the alternative for full profile briefs and listings.

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 when to use this tool ('Use this to connect directly to a brand for richer interaction') and names the alternative for a different need ('For the brand's full profile with briefs and listings, use get_brand instead'). This provides clear selection guidance relative to its most relevant 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?

The word 'Check' implies a read-only operation, which is a mild behavioral signal, but the description does not explicitly state absence of side effects, permissions, or error behavior. With no annotations provided, the description carries the full burden, and it only partially discloses behavior by listing the returned status attributes.

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, information-dense sentence with no filler. It front-loads the [CONCIERGE] tag and immediately states the action and the key data points returned, making it highly efficient.

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 conveys the main purpose and return contents, but lacks usage context, such as when to choose this over sibling tools or how the optional parameters interact beyond what the schema already says. There is no output schema, so the description partially compensates by listing return fields, but it is not fully 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 description coverage is 100%, and the schema already explains that agent_id and wallet_address are alternatives and one may be omitted. The description adds no additional meaning about the parameters, so it earns the baseline score for full 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 tool checks the status of a Personal Shopper or Concierge and lists specific status aspects (credit balance, preferences, LLM provider, operations remaining). The verb 'Check' is specific and the resource is unambiguous. It does not explicitly compare to siblings, but the focus on concierge status distinguishes it from similar tools like check_agent_standing.

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 guidance about when to use this tool versus alternatives, no prerequisites, and no exclusions. It simply states what it does without context on the appropriate scenario.

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 implies a read-only operation via 'Get' and adds a key dependency (brief ID needed for submit_design). However, it doesn't explicitly state side effects, error conditions, or authentication requirements, leaving some ambiguity for a 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 four short sentences, each with specific content: definition, usage instruction, return value, and optional param. No fluff, well-structured and 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 simple 1-param tool with no output schema, the description covers the essential purpose, usage trigger, and return value. It lacks details on response format or error handling, but for the tool's complexity, it is reasonably 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% for the single param brand_slug, and the description merely restates 'Optionally filter by brand_slug,' adding no new semantics 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 the verb 'Get' and the resource 'current design brief' with the qualifier 'active creative challenge.' It distinguishes from sibling list_briefs by emphasizing 'current' and mentions its role in submit_design, making the purpose unambiguous.

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

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

It explicitly instructs to call this or list_briefs FIRST when submitting a design, providing a clear usage context. It also mentions the optional brand_slug filter. However, it doesn't specify when to prefer this over list_briefs beyond 'current,' so it falls short of a full contrast.

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 full burden of behavioral disclosure. It states the tool works 'AFTER PURCHASE' and returns 'signed download URLs,' implying read-only access. However, it does not explicitly state that it is non-mutating, nor does it mention potential failure conditions (e.g., invalid buyerWallet/tokenId) or the expiry nature of signed URLs. The core behavior is clear but lacks explicit safety/edge-case 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?

The description is exceptionally concise: two sentences totaling 20 words. It front-loads the critical context with '[AFTER PURCHASE]' and every phrase ('previously purchased,' 'lost the original download link') adds meaningful guidance without 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 tool is simple (2 parameters, no output schema), and the description provides sufficient context for an agent to select and invoke it correctly. It explains the purpose and when to use it, and the schema fully documents parameters. The only minor gap is not describing the return format, but for a download-link retrieval tool, the description is adequately 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 description coverage is 100% for both parameters (buyerWallet and tokenId), with descriptive text in the schema. The description adds no additional parameter meaning 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 purpose: 'Retrieve signed download URLs for a previously purchased listing.' It uses a specific verb ('retrieve') and resource ('signed download URLs'), and the context 'previously purchased' distinguishes it from purchase-related tools like confirm_purchase or 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 explicitly provides usage guidance: 'Use if you lost the original download link from confirm_purchase.' This tells the agent exactly when to invoke this tool and even names the alternative source of the same information (confirm_purchase).

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 of behavioral disclosure. It adds useful context about the two leaderboard types and ordering ('in order' for the quest_slug mode), but it does not mention authentication, rate limits, pagination beyond the limit parameter, or response format. For a read-only get tool, this is adequate but not rich.

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

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

Two concise sentences, front-loaded with the tool's purpose. Every word earns its place, and the structure clearly separates the two modes. No filler or redundant rephrasing 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?

This is a low-complexity tool with only two optional parameters and no output schema. The description explains the core behavioral distinction between the two modes, which is the primary context an agent needs. It does not delve into response fields or ranking direction, but given the simplicity and the schema's documentation of limit, this is reasonably 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 input schema already documents both parameters with 100% coverage, so the baseline is 3. The description adds meaning beyond the schema by clarifying that omitting quest_slug yields the overall points ranking, which is not stated in the schema. It also reinforces the interpretation of quest_slug as 'first correct solvers ... in order', matching the schema's phrasing but adding the 'overall' contrast.

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 leaderboards') and the two distinct modes (overall points ranking vs. per-quest solver board). This is specific enough to differentiate it from any sibling tool, as no other tool is leaderboard-related. The verb 'get' is implied by the name and the description covers the main purpose without ambiguity.

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 mode ('Without a quest_slug' vs. 'With a quest_slug'), providing clear conditional context. However, it does not name any alternative tools or state exclusions, so it stops short of full when-to-use vs. when-not-to 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 shoulders the burden of behavioral disclosure. It adds useful context: the handbook works identically for humans and AI agents, and identity is just a Base wallet, which addresses authentication/access assumptions. It also details the contents (strategies, talking points, commission structure, technical details), giving the agent a clear idea of what to expect. However, it does not explicitly state that the tool is read-only or describe the return format, but the nature of 'get' and the content list mitigate this.

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 carrying meaningful information: naming clarification, accessibility/identity, and content overview. It is front-loaded with the core purpose ('Get...') and contains no filler. Every sentence earns its place, making it highly concise 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?

For a zero-parameter, static information retrieval tool, the description is mostly complete. It explains the content of the handbook and the identity requirement. However, with no output schema, it does not explicitly state the return format (e.g., markdown, text, URL), which is a minor gap but not critical for a simple 'get' tool. The description gives enough context for an agent to confidently 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 tool has zero parameters, so the schema offers no semantic burden. According to the rubric, 0 params warrants a baseline of 4. The description adds no parameter details, but there are none to explain, so it fully satisfies the dimension.

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 resource ('RRG Referral / Marketing / Affiliate Programme handbook') and the action ('Get'), making the tool's purpose unambiguous. It also differentiates from sibling tools by being the handbook for the marketing programme, whereas others like join_marketing_program or create_ref_link focus on actions. The content summary ('strategies, talking points, commission structure') adds specificity.

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 when a user or agent needs the handbook for earning commissions, but it does not explicitly state when to use this tool versus alternatives like join_marketing_program or create_ref_link. There are no exclusions or alternative recommendations, leaving the agent to infer the context from the tool's purpose.

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 that this tool reveals what RRG remembers, including 'patterns learned', and emphasizes transparency. It implies a read-only action via 'View' but does not explicitly state there are no side effects or special permissions required. This adds meaningful context about data collection behavior.

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

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

Three sentences: purpose, return contents, and a transparency note. Every sentence adds value, no redundancy, and the most important information is front-loaded in the first sentence.

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 view operation, the description sufficiently explains what the tool returns and how it fits into the agent's privacy expectations. No output schema exists, but the description covers the return categories. The required wallet parameter is documented in the schema, so no gap there.

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

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

Schema coverage is 100% and both parameters have descriptive text. The description's list of returned content overlaps with the query parameter examples but does not add new parameter-level meaning. The baseline of 3 applies as the schema already handles parameter documentation.

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 clear verb 'View' and specific resource 'your personalised agent profile', and enumerates the data returned (interaction history, purchase records, etc.). This distinguishes it from sibling read tools like get_points_balance or check_agent_standing.

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

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

The phrase 'View your personalised agent profile on RRG' clearly communicates when to use this tool, but it does not explicitly name alternatives or state when not to use it. Sibling tools exist for related checks, but no exclusions are provided. The context is clear enough for an agent to select it for profile-related queries.

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?

Without annotations, the description must carry the behavioral disclosure burden. It explains the voucher code format (RRG-XXXX-XXXX) and the redemption flow, which is useful domain context. However, it omits details about return format, pagination, or whether the list is sorted, so it's not fully 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?

Three sentences, front-loaded with the primary function, then essential context, then the parameter. No redundant phrases or fluff. The [BROWSE] tag is efficient.

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 domain and the follow-up action. It doesn't describe the return value structure, which might be needed for a complete mental model, but it's adequate for a developer to start using it. Given the 100% parameter coverage, 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 covers brand_slug with a clear description, giving a baseline of 3. The tool description repeats the filter capability ('Optionally filter by brand_slug') but adds no new semantic information beyond the schema. No format or example 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?

Description clearly states 'List active voucher offers (perks) from brands' – a specific verb and resource. It distinguishes itself from redeem_voucher by explicitly directing users to that tool for redemption, and from other list tools like get_redemption_offers by focusing on voucher 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?

Provides context that vouchers are bundled with purchases and that codes are redeemed via redeem_voucher, effectively steering users to the correct alternative action. It also mentions the optional brand_slug filter. However, it doesn't explicitly state when not to use this tool (e.g., for redeeming points or checking standing).

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 behavioral traits itself. It explains what points are (earned from purchases, quests, referrals, non-transferable) but does not state the tool's behavior, such as whether it performs a read-only lookup, the return format, or potential error conditions.

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 short and front-loaded with the core concept. The second sentence about how points are earned is somewhat extraneous but does not significantly bloat the description.

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 incomplete for a getter tool: it does not explicitly state that the tool returns the balance for the provided wallet, nor does it mention any response format or error handling. Without an output schema or annotations, more detail is needed.

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 provides 100% coverage for the single parameter agent_wallet with a clear description ('Agent wallet address on Base'). The tool description adds no parameter-specific meaning, 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 clearly indicates that this tool pertains to a VIA Points balance, distinguishing it from other get_* tools like get_agent_pass or get_offers. However, it lacks an explicit verb such as 'returns' or 'retrieves', relying on the tool name to convey the 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?

No guidance is provided about when to use this tool versus alternatives like check_agent_standing or redeem_points. There is no mention of prerequisites, context, or 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 full burden for behavioral disclosure. It explains the conceptual model (tiers trade points for brand vouchers) and notes the optional brand_slug filter, but does not describe return shape, pagination, or any side effects. For a simple read-only get, this is adequate but not rich.

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

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

The description is four short sentences, each earning its place: the core concept, the definition of a tier, the optional filter, and the redemption follow-up. It is front-loaded and waste-free.

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 one optional parameter and no output schema, the description covers the domain, the filter, and the next step in the workflow. It could be more explicit about the return type, but overall it's complete enough for the tool's complexity.

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

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

Schema coverage is 100% with brand_slug described as 'Optional brand slug to filter offers.' The description's mention 'Optionally filter by brand_slug' adds little beyond the schema, so baseline 3 is appropriate.

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

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

The description leads with 'What VIA Points buy: brand-published redemption tiers,' clearly identifying the tool as the way to view points-based redemption offers. It specifies the resource (redemption tiers) and the action (get), and distinguishes it from redemption action tools like redeem_points.

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 puts the tool in a transactional flow: it shows what points buy, then directs users to 'Redeem with redeem_points.' This provides clear usage context. However, it doesn't explicitly name alternative viewing tools like get_offers or describe when not to use this 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 burden. It discloses the read-only nature ('Check the status'), the sequence dependency (after submit_design), and the return contents (status, title, rejection reason). This adds valuable behavioral context 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 two sentences and front-loaded with the main action. The '[CREATE]' prefix is extraneous and could mislead, so it loses a point for not being fully streamlined.

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 status-check tool with one parameter and no output schema, the description fully covers what the tool does, when to use it, and what it returns. 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?

Schema description coverage is 100% for the single parameter (submission_id described as returned by submit_design). The description reinforces the usage context but adds no additional semantic meaning 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 checks status of a design submission, and distinguishes it from siblings by referencing submit_design specifics. However, the '[CREATE]' prefix is confusing and suggests a create action, which slightly detracts from clarity.

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 instructs to call after submit_design and states the purpose (find out if approved, rejected, or pending). This provides clear contextual guidance for when to use this 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 the full burden of behavioral disclosure. It describes the game mechanic (banking VIA Points on first find) but does not clarify the tool's own behavior—whether it returns a list, modifies state, or triggers rewards. The description could mislead an agent into thinking calling the tool yields points, as it states eggs bank points rather than clarifying that finding them (not retrieving them) does.

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, two sentences, and front-loaded with the core concept. Every sentence adds value—context, differentiation, and game mechanics—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 tool that retrieves world eggs, the description explains the context and types of eggs but omits what the tool actually returns (e.g., list of eggs, status, locations). Since there's no output schema, the description should clarify the return behavior. It provides necessary background but is incomplete for a full understanding.

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 only parameter, agent_wallet, is fully described in the schema with type and pattern, and the description doesn't mention it. Schema coverage is 100%, so the baseline of 3 applies; the description adds no additional 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 focuses on what world eggs are (hidden content, some open, some gated) rather than explicitly stating the tool's action, but the name 'get_world_eggs' combined with the description and the reference to 'discover_egg' for gated challenges makes it clear that this tool retrieves egg information. It distinguishes from sibling 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 implies that discover_egg is used for gated challenges, but it doesn't explicitly say when to use this tool vs alternatives. There's no clear 'use this when you need to list eggs' or 'do not use for...' guidance, leaving usage somewhat implied.

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

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

With no annotations provided, the description carries the full burden. It goes beyond a simple 'returns a map' by explaining the geographic representation of meaning, what the return includes (labels, centroids, counts), and the special VIA quarter with its own MCP endpoints. This gives the agent a clear behavioral model of the data returned, even though it does not discuss side effects, rate limits, or auth—likely irrelevant for a browse 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 single, well-organized paragraph with a clear flow: tag, definition, return values, special case, and use cases. Each sentence adds value, though some conceptual explanation (e.g., 'Geography = meaning') is slightly verbose but necessary for understanding the output. It is appropriately sized for the tool's complexity.

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 lack of an output schema and annotations, the description is remarkably complete. It explains the conceptual model, enumerates all return components (regions, centroids, counts, VIA quarter), and provides concrete use cases. It also links to related tools, helping an agent understand how this fits into the broader tool ecosystem. No significant 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 tool has 0 parameters, so the baseline is 4. The description compensates by clarifying what the output represents and how to interpret it, which is the main semantic need for a parameterless tool. No parameter documentation is needed.

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 resource ('Map of the RRG 3D world') and what it returns: every region with label, centroid coordinates, and product count, plus the VIA quarter. It also distinguishes this from sibling tools by explaining the map is the spatial projection of the product embedding space, and mentions search_products and get_drop_details as places where matching world positions appear, showing deliberate differentiation.

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

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

The description explicitly states when to use it: '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 implies that for individual listing positions, one should look at search_products or get_drop_details, providing context for alternatives, though without explicit exclusions or a direct 'do not use for' statement.

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 carries the full disclosure burden, and it delivers: the two-step settlement flow, the payTo/USDC amount target, the exact branching when shipping_rate_handle is omitted (returns live shipping options vs payment instructions), and the re-quote-at-settlement behavior. This is genuine behavioral disclosure beyond the function name.

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

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

Three focused paragraphs with the purpose and use-condition front-loaded before the workflow and the shipping edge case. Each block earns its place; there is minor redundancy with the schema's variant-mapping notes, but nothing wasted.

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

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

Complete for a 13-param tool with no output schema and no annotations: it explains the return value (payment instructions with payTo and exact USDC amount), the required follow-up tool (confirm_agent_purchase), and the shipping re-quote nuance. Parameters are covered by the 100%-coverage schema, and behavior is covered by the description.

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

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

Schema coverage is 100%, so the schema already documents all 13 parameters, placing this at baseline 3. The description adds workflow context (omit shipping_rate_handle to list options, re-quote at settlement, size/color matching variants) rather than new syntax, which is useful but not a semantic leap over the schema.

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

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

States a specific verb+resource ('Get payment instructions for a direct USDC transfer purchase') and sharpens scope with the [BUY, Agent Step 1] tag and the explicit EIP-712 exclusion, which separates it from the sibling initiate_purchase. An agent knows exactly what this does and how it differs from the signing-based alternative.

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

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

Gives an explicit when-to-use condition ('if you are an AI agent that cannot sign EIP-712 permits') and a clear post-call workflow (send USDC to payTo, then call confirm_agent_purchase with the tx hash). It stops just short of naming the signing-capable alternative (initiate_purchase) outright, so the exclusion is implied rather than fully spelled out.

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

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

With no annotations, the description carries the burden of disclosure. It reveals that the tool returns a permit payload requiring signTypedData, and that it is a buy operation intended only for human wallets. However, it doesn't describe post-signing steps (e.g., confirm_purchase) or any side effects, leaving slight ambiguity about the full workflow.

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 long, each earning its place. It front-loads the purpose and critical restriction, then explains the intended audience. No filler or redundancy.

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

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

Given the tool's complexity (EIP-712 permit, human wallet restriction) and the absence of an output schema, the description adequately explains what the tool returns, who should use it, and the alternative tool. It provides enough context for correct invocation without needing to list return structures.

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 fully documents tokenId, buyerWallet, selected_size, and selected_color. The description adds no additional parameter details beyond what is already in the schema, making the description redundant for parameter semantics. 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 the tool's function: 'Returns an EIP-712 permit payload that must be signed with signTypedData.' It specifies the resource (purchase permit) and action (initiate) with a specific output. It also distinguishes itself from the sibling tool initiate_agent_purchase by explicitly identifying this as the human-wallet variant.

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

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

The description provides explicit usage guidance: 'AI AGENTS: do NOT use this tool. Use initiate_agent_purchase instead.' and 'This tool is for human wallet apps (browser wallets, hardware wallets) that can sign EIP-712 permits.' It clearly states when to use and when not to, naming the alternative 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 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 provided, the description carries the burden of disclosing behavior. It states the tool retrieves an invite link and directory, which is a read operation, but does not mention whether authentication is required, any rate limits, or what the returned directory format is. This is adequate for a simple getter but lacks depth.

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 consists of two sentences that are front-loaded with the core action ('Get the RRG Discord invite link and channel directory') and followed by useful 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?

This is a simple zero-parameter tool with no output schema. The description explains what the tool returns (invite link and channel directory) and why the Discord matters. This is sufficient and complete for the tool's complexity.

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

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

The tool has zero parameters, and the schema is trivially complete (100% coverage with no properties). Per the rubric, a baseline of 4 is appropriate when there are no parameters, and the description does not need to explain anything further.

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 the RRG Discord invite link and channel directory.' This uses a specific verb (Get) and resource (Discord invite link and directory), and it is distinct from all sibling tools. The '[CONNECT]' prefix is an additional categorization clue.

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 context: the Discord is the hub for agent networking, listing notifications, and commerce alerts. This implies when the tool would be useful, though it does not explicitly mention alternatives or when not to use it. Since no similar sibling tools exist, this is clear enough.

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 the full burden. It discloses pagination behavior (via limit/offset and next_offset), return shape, cost implications (thousands of items, search_products is cheaper), and explicitly states that live on-chain minted count is not here but in get_drop_details. This is thorough and goes beyond basic expectations.

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 action and scope in the first sentence. It is longer than minimal but every sentence earns its place by addressing usage, return format, and scope limitations. Slightly verbose but well-structured and readable.

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 browse tool with no output schema, the description fully covers what the agent needs: purpose, return object fields, pagination mechanics, alternatives, and next steps. It also notes what information is intentionally absent (minted count). Complete and actionable.

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 good parameter descriptions. The tool description adds meaningful context: it explains the pagination pattern (pass next_offset back) and highlights the large catalogue size, making the limit parameter's purpose clearer. This enriches the schema without redundancy.

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: 'List active RRG listings, paginated, optionally scoped by brand_slug.' It uses a specific verb (list), identifies the resource (RRG listings), and differentiates from siblings by mentioning search_products for specific lookups and get_drop_details for minted counts.

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 when exploring the catalogue without a specific item in mind' and 'If you already have a product name, SKU, brand, or descriptive keyword, call search_products FIRST.' It also recommends next steps (get_drop_details + initiate_agent_purchase), making the tool's place in the workflow 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 provided, the description carries the full burden. It discloses the reward structure and prerequisite, but does not mention side effects (e.g., is the referral record irreversible?), whether duplicate referrals are allowed, or any rate limits. This is useful 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 compact and front-loaded with a category tag. Three sentences cover the action, reward, and prerequisite without 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?

For a logging tool with 5 parameters and no output schema, the description provides enough context: what it does, the prerequisite, and the reward. It lacks details on what happens after logging or potential errors, but given the simplicity, it is nearly 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 description coverage is 100%, so baseline is 3. The description adds context about the purpose of parameters (e.g., 'your_wallet' as marketing agent wallet) but largely mirrors the schema. It does not introduce meaning beyond what the schema already conveys.

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'), the resource (RRG), and the reward mechanism (10% of platform's share). It distinguishes itself from sibling tools like create_ref_link by focusing on logging an actual referral rather than generating a link.

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 an explicit prerequisite: 'You must be a registered partner (use join_marketing_program first).' This indicates when to use the tool. It does not explicitly contrast with alternatives, but the context of logging a referral is clear enough.

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 full transparency burden. It discloses key behavioral traits: spends banked points, issues a one-time voucher code, and prohibits provisional points. However, it does not mention irreversibility, authorization requirements, or potential error conditions, which are significant for a mutation 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?

The description is three concise sentences, each providing essential information: the action, the output, and a restriction. It is front-loaded with the primary verb and resource, and every sentence earns its place without 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 tool with 2 parameters and no output schema, the description covers the core function, the output, and a key precondition. It is largely complete, though it could mention that this is the precursor to redeem_voucher or explicitly note the points are deducted, but these gaps are minor given the schema and sibling context.

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 100% coverage for both parameters, with tier_id described as 'Redemption tier id from get_redemption_offers' and agent_wallet as 'Your agent wallet address on Base'. The description adds no additional parameter 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 action: 'Spend banked VIA Points on a redemption tier from get_redemption_offers.' It specifies the resource (banked points) and the output ('Issues a one-time RRG voucher code'). This distinguishes it from siblings like redeem_voucher, as it is the step that produces the voucher, not redeeming it.

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 workflow: first obtain a tier via get_redemption_offers, then use this tool. It also provides a clear constraint: 'Provisional points cannot be spent.' However, it does not explicitly name alternative tools or say when not to use it beyond the provisional points restriction.

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 explains the linking of human and agent into one VIA network member and banking the reward to the pair, which is useful. However, it does not mention reversibility, idempotency, or potential failure modes, leaving some uncertainty for a mutation-like action.

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, each earning its place: it states the action, provides the quest context, and explains the outcome. There is no redundancy or 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 tool with two well-documented parameters and no output schema, the description is fairly complete. It covers purpose, when to use, and the resulting effect. It could be more explicit about prerequisites or post-redemption behavior, but the existing context is solid.

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

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

Schema coverage is 100% and both parameters ('code' and 'agent_wallet') are fully described in the schema. The description adds minimal extra semantic value beyond reinforcing the code format and wallet network, so the baseline 3 applies.

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

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

The description uses a specific verb ('redeem') and resource ('cipher code') with the exact format (VIA-XXXX-XXXX), and distinguishes this from siblings like redeem_points and redeem_voucher by explicitly mentioning the two-player quest context and the linking of human and agent.

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 clearly states when to use this tool: when the human has found a cipher code in the 3D world at /world, and emphasizes that the agent must be the human's own agent. It does not explicitly name alternatives, but the context is sufficient to differentiate from other redemption 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, the description carries full burden and excels: it discloses rejection behavior (status 'needs_more_detail'), indexed fields, query pattern handling, ranking logic, size-specific response fields, pricing nuances (variantSummary vs priceRangeUsdc), and even zero-match fallback guidance. This goes far 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 long but front-loaded with the most critical guidance ('START HERE'), and organized into clear paragraphs with headers-like patterns. Every section earns its place given the tool's complexity, though some redundancy (e.g., repeated notes about per-size pricing) could be trimmed.

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

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

For a complex tool with no output schema, the description covers all essential aspects: return fields, size semantics, pricing interpretation, next steps, and failure recovery. It also accounts for edge cases like unavailable sizes and multi-naming clusters, making it fully self-contained for an agent to act 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?

Although schema coverage is 100%, the description adds substantial meaning beyond the schema: it explains query pattern semantics (SKU dash/space insensitivity, brand+category), auto-extraction of size, and how to use brand_slug (calling list_brands). It also clarifies the size parameter's effect on result structure, which is not obvious from the schema alone.

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

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

The description states a specific verb+resource ('Free-text search across every active RRG listing') and clearly differentiates from sibling tools by distinguishing defined intent from open browse. It also explicitly names list_drops as the alternative for browsing, making the tool's 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?

It provides explicit when-to-use guidance ('START HERE when you know what you want'), states when not to use it (generic browse words are rejected), and names alternatives ('To browse without intent, call list_drops instead'). It also gives concrete next-step instructions for purchases, which is highly actionable.

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

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

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, the description carries the transparency burden. It discloses key behavioral traits: attempts are capped per wallet (a limitation) and correct answers earn VIA Points (a consequence). This goes beyond simple mutation disclosure, though it does not specify what happens on wrong answers or how the response indicates success/failure.

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 long, front-loaded with the main action, and each sentence adds distinct value: action, constraint, and reward. No wasted 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 mutation tool with no annotations and no output schema, this description is adequate but lacks detail on return values, error cases, or whether wrong answers consume attempts. It does mention the attempt cap and reward, which provides some context, but the absence of outcome details leaves gaps that an agent might need to infer from sibling tools like get_submission_status.

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 does not add parameter-specific meaning beyond what the schema already provides; the schema already explains quest_slug origin, answer format (including tokenId for product riddles), and wallet pattern. No additional semantic value is added by the description.

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: submitting an answer to an active quest riddle. It uses a specific verb (submit) and resource (answer to quest riddle), and distinguishes itself from sibling tools like get_current_quest (retrieval) and redeem_quest_cipher (redemption) by focusing on the submission act.

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 usage context: it is for active quests, and it warns that attempts are capped per wallet, advising verification of reasoning first. It implies the need to fetch the quest slug via get_current_quest but does not explicitly state when not to use the tool or name 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 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.