MegaChad

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

The description adds useful behavioral context beyond the title: it discloses the refund mechanism ('The pair refunds whichever side is over-supplied') and staking eligibility ('LP shares returned are stake-eligible in JESTERGOONER V4'). However, it does not describe the tool's output (e.g., whether it returns a signed transaction or requires execution) or mention permissions/side effects. With no annotations, the description carries the burden but only partially covers it.

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

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

The description is two sentences, directly states the primary action first, and includes valuable extra context (refund and staking) without unnecessary verbosity. Every sentence contributes meaningful information.

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

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

This is a transaction builder with no output schema and no annotations, so the description should explain what the tool returns and how to proceed. It omits the return type (e.g., unsigned transaction data) and does not mention that the built transaction can be passed to sibling tools like build_execute_tx. The refund and staking notes are helpful, but the missing execution flow is a significant gap.

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

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

The input schema already provides 100% coverage with descriptions for all parameters (amountMC, amountMG, recipient, and optional address). The description adds minimal parameter-specific detail beyond associating amountMC and amountMG with the approve and addLiquidity steps. Baseline of 3 is appropriate 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 clearly states the tool's function: 'Build approve(MC) + approve(MG) + addLiquidity on MegaChadLP MC/MG.' It identifies the specific resource (MegaChadLP) and distinguishes it from sibling tools like build_amm_swap_tx and build_staking_tx by focusing on liquidity addition.

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

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

Usage context is implied through the description ('Build approve(MC) + approve(MG) + addLiquidity'), but there is no explicit guidance on when to use this tool versus alternatives such as build_amm_swap_tx or build_staking_tx. No exclusions or alternative tools are mentioned.

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

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

With no annotations provided, the description carries full responsibility. It discloses the exact two-step mechanics (ERC20.transfer then swap), the absence of on-chain minOut, the need to verify received balance, and that slippage is only surfaced off-chain as minOut. These are critical behavioral traits that are not in 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 three sentences, front-loaded with the purpose, and every sentence provides essential information. The warning about minOut and off-chain slippage are valuable 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 has no output schema and no annotations, but the description specifies the output is a two-step plan (including the call sequence) and notes the safety verification needed. For a transaction builder, this is sufficiently complete for an agent to invoke it and interpret the response.

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

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

Schema coverage is 100%, but the description adds meaning by explaining slippageBps is computed off-chain and surfaced as minOut, and that the transaction is a two-step sequence using amountIn/amountAIn/amountBIn. This bridges schema fields to the actual swap behavior, though it doesn't explicitly re-describe each parameter.

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

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

The description clearly states the tool builds a two-step swap plan for MEGACHAD↔MEGAGOONER via MegaChadLP, with an explicit transaction sequence. It distinguishes itself from siblings like build_amm_add_liquidity_tx and other build_* tools by specifying the swap action and assets.

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 intended use is clear from the purpose statement, but it does not explicitly name alternatives or exclusions. For example, it does not contrast with get_swap_quote for quotes or build_amm_add_liquidity_tx for liquidity. However, the context strongly implies when this tool is needed.

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 it only builds calldata (not executes) and mentions the 'payable' condition for actions with ETH value. However, it does not explicitly state that calling this tool has no side effects or what the return value is, leaving some ambiguity.

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

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

One sentence, front-loaded with the action, then the condition. No unnecessary words; every word earns its place.

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

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

For a single-parameter builder tool, the description covers the key prerequisites and behavior. But with no output schema, it omits what the function returns (e.g., calldata hex string) and whether it submits the transaction. It is adequate but 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?

The schema fully describes proposalId with type and bounds, so baseline is 3. The description adds meaningful context: the proposal must be queued and past the timelock, and that it is used in the execute function. This enhances understanding of how to provide the parameter.

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

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

The description uses a specific verb 'Build' and resource 'execute(proposalId) calldata' for a 'Queued Jestermogger proposal,' clearly distinguishing it from siblings like build_queue_tx or build_veto_tx. The purpose is unambiguous.

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

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

It specifies the exact precondition—'past its 2-day timelock' and 'Queued'—which tells the agent when to use this tool. However, it does not explicitly name alternative tools or state when not to use it, so it falls just short of the highest bar.

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

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

No annotations are provided, so the description carries the full burden. It mentions that only the top 3 burners can propose, which is domain context, but does not disclose whether the tool is read-only, what the response format is, or any side effects. The description focuses on eligibility logic rather than behavioral details of the tool invocation.

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 and relatively concise, but it mixes instructions for an external POST endpoint with the tool's own purpose, making the structure confusing. It could be more streamlined to focus solely on what this MCP tool does.

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

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

With no output schema and only a single parameter, the description should clarify the return value structure and how to interpret eligibility. It does not mention what the response contains (e.g., boolean, detailed eligibility check), and the misleading hint about POSTing to build calldata leaves the tool's scope incomplete.

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 'proposer' parameter, and the schema already explains it as a wallet address required for eligibility. The description does not add additional semantic meaning beyond the schema, so a baseline score of 3 is appropriate.

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

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

The description states that the GET form returns eligibility for the proposer, so the core function is somewhat clear. However, the tool name 'build_propose_tx' and title 'Build Propose TX / Check Eligibility' create confusion, as the description explicitly says to POST to an endpoint to build calldata, implying this tool does not build transactions. This weakens purpose clarity and fails to properly distinguish from other build_* 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 advises using the tool 'before drafting' a proposal, giving a minimal usage context. It does not explicitly state when NOT to use it, nor does it name alternative MCP tools for building calldata; instead it refers to an external HTTP POST. This confusion about whether to use this tool or another method makes usage guidelines weak.

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 behavioral transparency burden. It discloses the key side effect (starting the 2-day timelock) and the prerequisite (Succeeded state), which are the most critical behavioral traits. It does not cover failure modes or additional restrictions, but the disclosed information is sufficient for basic use.

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, front-loaded with the verb and resource. It includes all essential information without any 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?

Given the tool's simplicity (one fully documented parameter, no output schema) and the presence of sibling tools, the description is complete. It explains what it does, when to use it, and the consequence, making it fully adequate for an agent to select and invoke 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 fully describes the only parameter as 'Proposal ID (1-indexed)' with min/max constraints. The description merely echoes '(proposalId)' without adding extra semantic detail, so the baseline of 3 applies due to high schema coverage.

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

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

The description clearly states the tool builds queue calldata for a Succeeded Jestermogger proposal, using a specific verb and resource. The phrase 'queue(proposalId) calldata' distinguishes it from siblings like build_execute_tx or build_propose_tx, which handle different governance actions.

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

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

The description provides a clear usage context: it is for proposals that have already 'Succeeded' and it starts the 2-day timelock, after which execution becomes possible. This implies the workflow position but does not explicitly name alternative tools or exclusionary conditions.

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: results are ready-to-sign tx objects with {to,value,data} for eth_sendTransaction, stake yields approve+stake while unstake/claim yield a single tx. It does not mention failure modes or auth, but covers the primary runtime 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, front-loaded with the core purpose; each sentence adds a distinct detail (scope, action-specific output count, returned item shape) 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?

Given the lack of an output schema, the description appropriately defines the return item structure, and the schema covers the parameter constraints. It explains the multi-transaction nature of stakes, so an agent has enough to invoke correctly, though it omits edge-case handling like insufficient allowance.

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 the schema already documents all four parameters at 100% coverage, the description adds meaning by explaining the action-to-transaction-count mapping and the token specifics for each venue (MEGACHAD vs MC/MG LP), supplementing the schema's property descriptions.

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

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

The description clearly states the tool builds ready-to-sign staking transactions for stake/unstake/claim across two named venues, distinguishing it from AMM/swap/proposal builder siblings. Uses specific verb 'Returns ready-to-sign transactions' with explicit venue/action scope.

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?

Describes the two venue options and their corresponding tokens, plus the action-dependent output shape, giving clear context for when to invoke. Does not explicitly name alternative tools to avoid, but the scope is sufficiently bounded by naming the venues and actions.

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 key behaviors: it builds calldata, may include an extra startVetoVote() step if no veto window is opened, and voter parameter triggers membership/duplicate-vote checks. It does not mention whether it sends the transaction or just returns calldata, but 'build calldata' strongly implies it is a builder, and the extra behavior is well explained.

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

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

Three sentences, front-loaded with the core purpose, and each adds necessary context: the support mapping, the conditional extra step, and the optional voter role. No wasted words; structure is clear and 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?

Given the moderate complexity (3 params, no output schema), the description covers the main logic, including edge-case behavior (veto window not opened) and optional validation. It doesn't specify the return format in detail, but 'response includes an extra step' gives a hint, and the build_ naming convention implies transaction construction. Overall adequate for agent reasoning.

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 real value beyond schema: it explains the conditional interaction between proposal state and the response (startVetoVote step), and expands voter semantics to include duplicate-vote checks, not just council-membership. This helps an agent pass the right parameters and interpret results.

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

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

The description uses the specific verb 'Build' with the resource 'castVetoVote calldata on NFTVetoCouncil', clearly distinguishing this from sibling tools like build_vote_tx or build_execute_tx. It also clarifies the support parameter meaning (yes = veto, no = defend), further pinning down the purpose.

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 this tool (for veto/defend actions on NFTVetoCouncil) and provides concrete context like the conditional startVetoVote() step and optional voter check. However, it does not explicitly name alternative tools or state 'use this instead of X', but the scope is clear enough for an agent to choose it appropriately.

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 adds useful behavioral details such as the supported vote options and that vote weight is based on MEGAGOONER balance at snapshot. However, it does not mention whether the tx is submitted directly, what side effects exist, or the return format, leaving some ambiguity.

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

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

The description is only two sentences, front-loads the core action, and contains no fluff. Every sentence adds value, 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 tool is simple, but with no output schema or annotations, the description should state what the built transaction returns or how it will be used. It omits return format and prerequisites, though it includes the key behavioral detail about vote weight, making it adequate but with 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 input schema already fully documents both parameters with descriptions, so the baseline is 3. The description repeats the enum values ('for | against | abstain') and adds vote-weight context, but it does not materially improve parameter understanding beyond the schema.

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

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

The description opens with the specific verb 'Build' and target 'castVote tx on Jestermogger', clearly distinguishing it from siblings like build_propose_tx and build_execute_tx. It immediately conveys the tool's exact action and resource.

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

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

It clearly identifies the tool's purpose—constructing a vote transaction—and provides context about supported values and vote weight, which implies when it should be used. It does not explicitly name alternatives or exclusions, but the context is unmistakable.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions sending a message and receiving responses, but fails to disclose potential side effects (e.g., intents like swap/bridge may execute transactions), whether wallet context is required for some intents, error behavior, or any rate limits. This is a significant gap for a tool that can perform actions.

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

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

The description is a single, front-loaded sentence that states the action and outcome, followed by a concise list of supported intents. There is no redundant or filler content; every word contributes to understanding the tool's scope. Length is appropriate for the tool's breadth.

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

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

The tool has no annotations and no output schema, so the description must explain behavior comprehensively. It lists intents but does not describe what the structured responses look like, how intents are resolved, or whether certain intents require additional inputs like wallet. For a chat tool covering many intents, the description is incomplete and leaves the agent uncertain about invocation and expectations.

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 adds context by listing intents, which gives meaning to the 'message' parameter beyond the schema's generic 'Natural language query.' However, it does not elaborate on when the 'wallet' parameter is needed (e.g., for wallet-specific intents). The added value is marginal but not absent.

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: 'Send a plain English message and get back structured, actionable responses.' It also enumerates supported intents (price, stats, wallet, etc.), which distinguishes it from the sibling tools that each handle a single specific function. This makes the purpose specific and 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 implies usage via the intent list, suggesting this is a general entry point for multiple queries. However, it does not explicitly state when to use this tool instead of calling sibling tools directly, nor does it mention any situations where this tool should not be used. Clear context but no explicit exclusions 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?

With no annotations, the description carries the behavioral disclosure burden. It clearly states that the tool returns a 'plan' with instructions, not that it executes anything, which inherently signals read-only behavior. It also describes the return content in useful detail (bridge URLs, calldata, burn instructions), going beyond a minimal description. However, it does not explicitly state that it does not execute transactions or mention any potential side effects, leaving slight ambiguity.

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

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

The description is a single, well-structured sentence that front-loads the primary action ('Build a cross-chain looksmaxx plan'). It efficiently conveys scope, output, and supported chains without any 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?

The description is fairly complete for a planning tool with no output schema. It explains what the tool does, the input context (supported chains), and what the output will be (step-by-step plan with specific artifacts). It could be more complete by explicitly noting that no funds are moved or providing a comparison to related sibling tools, but given the complexity, it covers the essentials well.

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

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

The input schema already has 100% coverage with descriptive parameter names and descriptions. The tool description adds context by listing supported chains and the nature of the plan (bridge URLs, calldata, burn instructions), which helps understand the purpose of the parameters. However, it does not add any specific parameter syntax or behavioral details beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('Build') and resource ('cross-chain looksmaxx plan') with a clear scope (from supported chains to MegaETH). It distinguishes itself from sibling tools by specifying the output (bridge URLs, swap calldata, burn instructions) and enumerating source chains, making it unique among the more generic get_* and build_* 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 clearly implies when to use it: when you need a cross-chain plan from one of the listed chains to MegaETH. However, it does not explicitly state when to use this over alternatives like get_looksmaxx_plan or get_bridge_info, nor does it mention exclusions. The context is clear but not exhaustive.

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 clearly states that the tool returns unsigned data and does not execute the burn—it explicitly defers the actual relay to a POST call. This prevents misuse as a direct burn execution 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?

Two sentences with no waste: states the return value, the signature step, and the next action.

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

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

For a simple one-parameter info getter, the description covers purpose, output, and follow-up action. Lack of output schema is mitigated by the explicit mention of signature payload and approval 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?

The sole parameter `address` is fully described in the schema ('Wallet address (0x...)'), so the description adds no additional semantics. 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 clearly specifies a 'get' operation for EIP-712 typed data specific to gasless burns, distinguishing it from transaction-building siblings by focusing on the signing payload and approval check.

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 outlines the workflow: get the payload, have the wallet sign, then POST to a relay endpoint. This implies the tool is for preparing gasless burns, though it doesn't explicitly name alternatives like build_* tools.

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

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

With no annotations, the description carries the transparency burden. It discloses the default block window and event limit ('last 2000 blocks (~8 min on MegaETH), 50 events'), the event types included, and the time-ordered nature. This goes beyond the basic read-only implication of the name and gives useful behavioral context.

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

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

The description is a single, well-structured sentence that front-loads the core purpose ('Unified time-ordered feed') and then provides relevant specifics. Every clause adds value, and there is no filler or repetition of the title.

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

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

For a simple read-only feed with two optional parameters, the description is reasonably complete. It covers what events are included and the default scope. The lack of an output schema is mitigated by the clear enumeration of event categories, so an agent knows what to expect. A small gap is the absence of any note about pagination or return structure, but it is not critical.

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

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

The schema already documents both parameters with descriptions, so the baseline is 3. The description adds meaningful context by explaining that the 'blocks' parameter corresponds to a time window ('~8 min on MegaETH'), which helps the agent understand the real-world impact of the parameter beyond the schema's dry definitions.

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 provides a 'unified time-ordered feed of recent on-chain events across the MEGA Protocol stack,' listing specific event types. This distinguishes it from sibling tools that target individual protocols or specific data, making its purpose unambiguous.

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

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

The description gives clear context on when to use this tool: for a broad, cross-stack activity feed. It does not explicitly mention alternatives or when not to use it, but the scope is well-defined enough that an agent can infer its applicability.

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

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

No annotations are provided, so the description carries full burden. It discloses that the tool returns 'the complete surface in a single response,' but does not mention side effects, authentication, rate limits, or output structure. For a read-only directory, this is adequate 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, both of which earn their place. It front-loads the purpose ('Master directory...') and immediately follows with usage guidance ('recommended first call'), with zero 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?

Given the tool's simplicity (0 parameters, no output schema), the description covers the key aspects: what it returns, what it includes, and how it fits into the broader toolset. It could be more specific about response format, but it is sufficient for this complexity.

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

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

The tool has zero parameters (empty schema), so the baseline score is 4 per the rubric. The description adds context about the tool's scope, but no parameter-specific details are needed since there are none.

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

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

The description clearly identifies the tool as a master directory of all MegaChad endpoints, MCP tools, manifest URLs, and examples. This specific verb+resource combination distinguishes it from the many other get_* sibling tools, which target individual 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 explicitly states 'The recommended first call for any agent,' providing clear context on when to use this tool. It does not explicitly mention alternatives or exclusions, but the guidance is sufficient for a directory 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?

No annotations are provided, so the description carries the full burden. The verb 'Returns' implies a read-only operation, and the listed data fields clarify the output. However, it does not disclose potential failure modes, authorization requirements, or any other behavioral traits beyond the return content.

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

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

A single, well-structured sentence that front-loads the verb 'Returns' and then lists the key data categories. No wasted words, and the information density is high.

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 getter with no output schema, the description sufficiently lists the return categories (registration metadata, identity, reputation count, contract addresses). However, 'registration metadata' is somewhat vague and could be expanded, but the overall coverage is adequate for the tool's simplicity.

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 baseline for 0 params is 4. The description adds value by enumerating exactly what data is returned, compensating for the lack of an output schema and giving the agent a clear idea of the tool's scope.

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 that the tool returns ERC-8004 registration metadata, on-chain agent identity, reputation client count, and contract addresses. It is specific about the resource and data returned, but it does not explicitly differentiate from sibling tools like get_identity or get_agent_index, which may have overlapping purposes.

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 on when to use this tool versus alternatives. It does not mention use cases, prerequisites, or when a sibling tool might be more appropriate. The agent is left to infer usage solely from the data-returning nature.

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. It discloses the AMM type (constant-product), fee (0.3%), return values, and the unusual tokenA/tokenB behavior that makes standard routers fail. It doesn't explicitly state this is a read-only operation, but 'quote' implies no mutation, and no side effects are suggested.

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

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

Four sentences, each with a distinct purpose: purpose, return values, the critical warning with alternative, and the omission usage. No redundancy, front-loaded with the primary action, and efficiently packed with necessary technical details.

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 quote tool with no annotations and no output schema, the description adequately explains what the tool returns (expected output, price impact, spot prices) and why it's needed (tokenA/tokenB incompatibility). It also covers the optional-parameter behavior, making the tool's behavior fully understood in 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?

Schema covers both parameters fully (100% coverage), so baseline is 3. The description adds value by explaining that omitting both parameters switches to reserve inspection, which is not derivable from the schema alone. This added semantic nuance justifies 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?

Description opens with 'Quote a swap on the MegaChadLP MC/MG pair', a specific verb+resource. It lists return values (expected output, price impact, spot prices) and warns about the pair's non-standard tokenA/tokenB ordering, distinguishing it from generic quote tools like get_swap_quote.

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 says 'standard Uniswap V2 routers do not detect it — use this tool', naming an alternative and directing to use this tool. Also gives a concrete usage mode: 'Omit from + amount to just inspect reserves', clearly explaining when to use the optional parameters.

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 is the only source of behavioral info. It discloses the output content (bridge info, canonical/aggregator) and the context (chains), but does not state whether the operation is read-only, needs auth, or any other behavioral details. It adds some value but lacks rich context.

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

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

The description is two sentences, front-loaded with the main purpose and a second sentence adding output details. No redundant words, perfectly concise.

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

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

For a zero-parameter, no-output-schema tool, the description sufficiently covers what the tool does and what it returns. It could have added return-shape details, but the simplicity of the tool means the current description 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?

The tool has zero parameters, and the input schema is empty. According to the rubric, 0 params gets a baseline of 4. No explanation of parameters is needed since there are none.

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

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

The description clearly states the tool returns bridge information for moving assets to MegaETH from listed chains, and specifically mentions canonical and aggregator bridges. This is a specific verb+resource+scope, and no sibling tool covers bridges, so it distinguishes well.

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

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

The description implies when to use the tool—when needing bridge info for moving assets to MegaETH from Ethereum, Arbitrum, Base, and other chains. It provides clear context but does not explicitly name alternatives or exclusions, 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?

No annotations are provided, so the description carries the full burden. It discloses the ranking order and contents (reputation scores, domain names, profiles, images), which is more informative than a bare 'get leaderboard.' However, it does not mention potential pagination or exact return format.

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, tightly written sentence that front-loads the key purpose and enumerates the included data. Every phrase adds value, with no redundancy or 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 zero-parameter read-only tool with no output schema, the description sufficiently conveys the return value's content and ordering. It lacks an explicit statement about the result being an array or any limits, but these are reasonable assumptions for a leaderboard.

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 zero parameters, and schema coverage is trivially 100%. Per the rubric, 0 params earns a baseline of 4; the description adds no parameter-specific details but none are 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 uses a specific verb 'Returns' and identifies the exact resource: 'burner leaderboard ranked by total burns.' It also lists the included data types, making it distinct from other getter 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 implies it should be used for leaderboard data but does not explicitly state when to use it over sibling tools like get_agent_index or get_activity_feed. No alternatives or exclusions are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates read-only behavior via 'Returns' and adds transparency by including the exact formula for weekly emissions. However, it does not disclose potential caveats such as whether the data is pulled live from the chain, data freshness, or any error conditions. The formula and scope of returned data are helpful 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 exceptionally concise, using two sentences to convey the full scope of the tool. The first sentence front-loads the primary purpose and key data components, while the second provides the exact mathematical formula. No words are wasted, making it highly efficient and well-structured.

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

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

For a zero-parameter read tool with no output schema, the description is quite complete. It enumerates all the major data points returned (full schedule, current week, on-chain weekly emission, EmissionController split) and includes the formula. The main gap is the lack of detail about the output format or structure (e.g., whether it returns an array), but for such a simple tool, this is a minor omission.

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 input schema is empty, so there are no parameter semantics to explain. The description correctly focuses on the tool's output. The baseline for a zero-parameter tool is 4, and since the description does not need to compensate for any parameter documentation gaps, it deserves this score.

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

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

The description clearly states the tool's function with the verb 'Returns' and identifies the resource as the MEGAGOONER emission schedule. It provides specific details about the schedule (225-week duration), additional data components (current week, on-chain weekly emission, EmissionController split), and even includes the formula. This distinguishes it from sibling tools that focus on other metrics or build transactions.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites, or alternative tools for related data. The intended usage is implied by the tool's name and description, but the dimension requires explicit 'when to use' or 'when not to use' guidance, which is absent.

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 disclosing behavior. It lists the return fields, which is helpful, and 'browse' implies read-only. However, it doesn't mention pagination behavior, ordering, or any potential side effects, though for a read-only gallery tool the risk is low.

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

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

A single sentence effectively communicates purpose and return data. No filler or redundancy. The verb appears first, followed by the resource and key fields, making it easy to scan.

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 read tool with only two parameters and no output schema, the description is largely sufficient. It names the resource and the fields returned. It could be more complete by stating the return shape (array of objects) or pagination behavior, but those are partially inferable from the schema.

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

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

Schema coverage is 100%: limit and offset each have descriptions including defaults and bounds. The description adds nothing beyond the schema, as 'recent' hints at ordering but doesn't define it. Baseline of 3 is appropriate when the schema already documents parameters fully.

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: browsing recent looksmaxxed burns and listing the specific data fields returned (IPFS URLs, addresses, timestamps, token IDs). The verb 'browse' implies a read-only list operation, and the resource is well-defined. It is distinct from siblings like get_activity_feed, though it doesn't explicitly name alternatives.

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

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

The usage is implied by the description: use when you need to browse recent looksmaxxed burns. However, it provides no explicit guidance on when to use this over related tools like get_activity_feed or get_nft_inventory, and lacks any exclusions or contextual prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It discloses what data is returned, including the conditional nature of the voter receipt ('if voter passed'), which is useful behavioral context. It does not mention error handling or edge cases, but for a getter this is adequate.

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

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

The description is a single, front-loaded sentence that packs specific details without redundancy. It uses a colon to enumerate return components efficiently, earning its place with zero waste.

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

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

Given the tool's simplicity (2 parameters, no output schema), the description is sufficiently complete. It outlines all key return elements and the conditional receipt. It does not cover potential error scenarios, but those are not expected for a basic read tool.

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

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

Schema description coverage is 100%, with both parameters (proposalId and voter) clearly described in the schema. The description adds slight extra meaning by clarifying the voter parameter's purpose as fetching the receipt if the voter passed, but it does not significantly enhance 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 retrieves full state for one proposal, listing specific components: actions, vote tally, NFT veto council status, and voter receipt if available. This distinguishes it from sibling tools like list_governance_proposals and build_propose_tx.

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 use when a single proposal's detailed state is needed, but it does not explicitly mention when to use it over list_governance_proposals or other alternatives. The context is clear but lacks explicit when/when-not guidance.

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

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

With no annotations, the description carries the burden of explaining behavior. It explicitly states the operation (resolving a name/address) and lists the returned data fields, which conveys the read-only nature. It does not cover error handling or edge cases, but for a straightforward lookup this is reasonable.

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: a purpose, a returns list, and a contextual framing. It is front-loaded with the main verb and resource, and no sentence is redundant or wasted.

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

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

For a single-parameter lookup with no output schema, the description gives a solid overview of the operation and return data, plus the broader 'social identity layer' context. It could be more complete by mentioning error behavior or an example, but overall it is adequate for typical use.

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 param description already documents the format (wallet address or .mega name). The tool description's phrase 'wallet address or .mega name' adds no new meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states a specific verb ('Resolve') and resource ('wallet address or .mega name' into an identity profile), and lists concrete return fields. It positions the tool as the 'social identity layer' which conceptually distinguishes it from siblings, but it does not explicitly compare against sibling tools, so it falls short of a 5.

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

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

The description implies this is the go-to for identity resolution and frames it as the 'social identity layer for MegaETH,' suggesting when it is appropriate. However, it does not explicitly name alternatives or state when not to use it, leaving the differentiation to the reader.

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 disclosing behavior. It reveals that the tool returns instructions rather than executing transactions ('ready to sign'), describes the ordered step flow, and mentions calldata. It could go further by explicitly stating it does not modify state or require signing, but 'ready to sign' provides strong implication.

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-loads the primary purpose, and every clause adds value. It avoids redundancy and clearly communicates the core return structure without 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?

Given the tool has no output schema, the description compensates by explaining the return values: an ordered set of transaction instructions with pre-built calldata. It names the flow steps and implies the optional ethAmount behavior indirectly. It is complete enough for an agent to understand what this tool provides and how it fits among sibling builders.

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 explains both wallet and ethAmount. The description adds no extra parameter meaning beyond the flow context, but because the schema is adequate, 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 returns a complete, ordered set of transaction instructions for the looksmaxx flow, naming specific steps (swap → burn → tren fund → submit) and the key output (pre-built calldata ready to sign). This distinguishes it from sibling single-transaction builders like build_amm_swap_tx and build_execute_tx.

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 for obtaining the full looksmaxx plan rather than individual transactions, but it does not explicitly state when to prefer this over sibling builders or when not to use it. No alternatives are named, so guidance is only inferred from the 'full looksmaxx flow' phrasing.

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. It frames the tool as a read operation ('Returns') and discloses what is included, which gives a clear behavioral picture for a simple no-parameter getter. It stops short of detailing error conditions, auth needs, or response format, but for this simple tool the disclosure is solid.

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

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

Two sentences, front-loaded with the core purpose, and each clause adds information (requirements, included contents). 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 simple 0-parameter tool with no output schema, the description covers the essential return content (x402 payment, burn requirements, instructions, addresses, amounts). It is sufficient for an agent to know what to expect and when this tool is relevant, though a bit more detail on the response structure could push it to 5.

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

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

The tool has zero parameters, so the description cannot add parameter meaning; the baseline of 4 applies. Schema coverage is trivially 100% with no properties, so no parameter documentation gap exists.

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 'Returns the x402 payment requirements and $MEGACHAD burn requirements for looksmaxxing', using a specific verb and resource. It also enumerates included elements (step-by-step instructions, contract addresses, amounts), distinguishing it from siblings like get_looksmaxx_plan.

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 you need payment/burn requirements for looksmaxxing, but provides no explicit when-to-use guidance or mention of alternatives. Given sibling tools like get_looksmaxx_plan exist, the overlap is not addressed, leaving usage context entirely implicit.

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 transparency burden. The verb 'Returns' strongly implies a read-only, side-effect-free operation, which is sufficient for a simple stats getter. However, it does not explicitly mention caching, error handling, or other behavioral caveats.

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

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

The description is one concise sentence that enumerates all key output fields without any filler. It is efficiently structured and front-loaded with the purpose.

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

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

Given the tool's simplicity (no parameters, no output schema), the description is complete: it states exactly what data is returned. No additional context is needed for an agent to invoke and interpret the tool correctly.

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

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

The tool has zero parameters, and the schema is empty, so there is nothing for the description to add regarding parameters. The baseline of 4 for 0-param tools 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 explicitly states 'Returns current $MEGACHAD token statistics' and lists the specific fields returned (total supply, circulating supply, tokens burned, total burn count). This clearly identifies the resource and purpose, and differentiates it from sibling tools like get_price or get_emission_schedule.

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 implies the tool is used whenever current $MEGACHAD token stats are needed, but it does not explicitly contrast it with alternatives or provide exclusions. The context is clear enough for an agent to select 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?

No annotations are provided, so the description must fully disclose behavior. It states the return content (protocol categories, addresses, features, links) but omits any details about read-only behavior, data freshness, pagination, or potential side effects. The verb 'Returns' implies a read operation, but without annotations, the transparency is minimal.

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, leading with the action verb 'Returns' and providing concise, relevant details (protocol types, included data). Every sentence earns its place with 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?

The tool has no params, no output schema, and no annotations, so the description carries the context burden. It adequately describes the content (protocol types and included fields) for a simple directory lookup, but lacks usage guidance or clarification on how it relates to get_protocol_registry. Given the low complexity, this is nearly complete, but the missing sibling differentiation prevents a 5.

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 is empty with zero parameters, so there are no parameters to describe. According to the rubric, 0 params warrants a baseline score of 4. The description doesn't need to add parameter details, and it doesn't contradict 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 states a specific action ('Returns') and resource ('curated directory of protocols on MegaETH'), with concrete examples (DEXes, bridges, payment infra, storage, identity systems) and content details (contract addresses, features, links). This clearly distinguishes it from siblings like get_bridge_info (specific bridge details) and get_protocol_safety (safety ratings).

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 no explicit guidance on when to use this tool versus alternatives. It implies a general directory lookup, but there is no mention of when to prefer it over similar siblings like get_protocol_registry or get_bridge_info. No exclusions or alternative contexts are provided.

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 explains the tool's logic (eligibility requires 1+ NFT) and gives practical context about zero-reward staking. However, it doesn't detail the exact return format or whether the operation is read-only, though the 'get' prefix implies that.

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

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

The description is two sentences, front-loads the core output (count, tiers, verdict), and uses the second sentence for usage guidance. Every word earns its place with no redundancy or 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 single-parameter, read-only-style tool with no output schema and no annotations, the description effectively covers purpose, key outputs, and the critical usage context. It provides enough details for an agent to select and invoke the tool correctly, including the practical implication of zero NFT holdings.

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

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

The input schema already describes the address parameter with 100% coverage. The description adds minimal extra meaning beyond referring to 'wallet' — no additional format, constraints, or behavioral nuances for the parameter are provided. Baseline 3 is appropriate since the schema handles the 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 clearly states the tool's function: returning MEGACHADNFT count, boost tier (1+/10+/25+), and staking-reward eligibility verdict. It uses specific verbs and resources and distinguishes itself from siblings by explicitly mentioning staking eligibility, which is unique among the get_* 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 instructs to use this tool BEFORE building any stake transaction, with a clear rationale: a wallet with 0 NFTs accrues 0 rewards even when staked. This provides direct guidance on when to use the tool versus alternatives like build_staking_tx.

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 the return contents (image URL, attributes, storage properties) and storage location (IPFS or Warren on-chain), which is useful. However, it does not mention side effects or error behavior, and the terms 'looksmaxxed' and 'Warren on-chain' are unexplained, leaving some ambiguity.

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

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

The description is a single, front-loaded sentence that efficiently conveys the core purpose and key output details. There is no redundant information or filler, earning a top score.

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

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

For a simple getter with one parameter and no output schema, the description is reasonably complete: it states what is returned and mentions image storage types. However, it lacks context about what 'looksmaxxed' means, potential failure modes, and whether it works for all ERC-721 NFTs or only a specific collection. This slight gap prevents a 5.

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

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

Schema description coverage is 100%, with tokenId described as 'NFT token ID (numeric string)'. The description adds no additional parameter meaning beyond stating it is for a 'looksmaxxed NFT', which is a collection-level qualifier rather than a parameter detail. Baseline 3 applies because the schema fully documents the parameter.

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

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

The description clearly states the tool 'Returns ERC-721 metadata for a looksmaxxed NFT' with specific contents (image URL, attributes, storage properties). This distinguishes it from siblings like get_nft_inventory, which likely returns a list of owned NFTs, and get_gallery, for a gallery view.

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

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

Usage context is implied: the tool is for fetching metadata for a specific NFT (by tokenId). However, there is no explicit guidance on when to use this vs. siblings, such as 'use get_nft_inventory to list NFTs first' or 'use this for metadata only'. No exclusions or alternatives are mentioned.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool returns formatted balances with raw values, which gives some behavioral context. However, it does not explicitly state read-only behavior, error handling, or any side effects. The verb 'get' implies a read operation, but deeper transparency is lacking.

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

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

The description is a single, front-loaded sentence that state the purpose, lists tokens, and notes output format. No redundant words, and every element earns its place.

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

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

With one required parameter and no output schema, the description adequately explains the input (wallet address), the scope (MegaETH tokens), and output (formatted balances with raw values). It lacks details like error conditions or network, but for a simple getter, this 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?

Schema description coverage is 100% for the address parameter, so the schema already documents it. The description adds a wallet context but does not add any new parameter semantics beyond what the schema provides. 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 gets all MegaETH token balances for a wallet, listing specific tokens (ETH, WETH, $MEGACHAD, USDm). This is a specific verb+resource pairing that distinguishes it from sibling tools like get_wallet_info or get_megachad_stats.

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 context: use when you need MegaETH token balances for a wallet. However, it does not explicitly mention alternatives or when not to use this tool, leaving the agent to infer based on tool names rather than receiving direct guidance.

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

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

With no annotations, the description carries the full burden. It states the tool 'Returns' data, implying a read-only operation, but it does not explicitly mention side effects, data freshness, or any authentication/rate-limit requirements. For a simple getter, this is adequate but not thorough.

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 front-loads the primary purpose (price) and appends the secondary feature (burn cost). No unnecessary 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?

For a low-complexity, zero-parameter tool without an output schema, the description clearly enumerates what is returned (price and burn cost) and the source (Kumbaya DEX). It is complete enough for an agent to select and invoke correctly.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description appropriately does not need to explain parameter behavior, as there are no inputs.

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

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

The description uses the specific verb 'Returns' and clearly identifies the resource ($MEGACHAD price in ETH from Kumbaya DEX). It also mentions a unique secondary output (estimated burn cost for 225,000 tokens), which distinguishes it from sibling price/quote 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 implies usage (whenever you need the current $MEGACHAD price or burn cost), but it does not explicitly contrast this tool with alternatives like get_amm_quote or get_swap_quote. No exclusions or when-not-to-use guidance is provided.

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 that the registry includes 'known gotchas' and direct links to endpoints, which adds context, but it does not explicitly state read-only behavior, safety implications, or return format. As a getter, risk is implied low, but the description could be more explicit about side effects (none) and data completeness.

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 yet information-dense, using two sentences to convey scope, contents, and priority. It is front-loaded with 'Canonical machine-readable registry' and every clause adds specific value—no filler or repetition.

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

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

Despite having no output schema, the description thoroughly explains the return value: a registry with addresses, proxy/impl, ABIs, gotchas, and links. It also covers usage context ('Pull this FIRST') and the breadth of contracts. For a zero-parameter tool, this is complete and self-sufficient.

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

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

The tool has zero parameters, so the description need not explain parameter semantics. The baseline for zero parameters is 4, and the description adds value by detailing what the registry contains, which is more relevant than parameter docs here.

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

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

The description clearly identifies the tool as a canonical registry of all MEGA Protocol contracts, enumerating specific categories (tokens, AMM pair, staking, governance, emissions, safety) and key contents (addresses, ABIs, gotchas). It uses a specific verb+resource and distinguishes itself from sibling get_* tools by its exhaustive scope and 'registry' framing.

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 instructs 'Pull this FIRST for any DeFi interaction,' providing a clear when-to-use directive and positioning it as a prerequisite. It does not explicitly name alternatives or when-not-to-use scenarios, but the context is unambiguous given its registry role.

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 strongly implies a read-only side-effect-free operation by describing 'state' and 'composition', and adds the important behavioral consequence that paused status causes every staking/AMM/governance write to revert. It does not explicitly state 'read-only', but the language is sufficient for a simple zero-parameter getter.

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: it first lists what the tool returns, then immediately explains why it matters. Every clause adds value and there is no wasted wording.

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

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

For a zero-parameter read tool, the description fully covers what the agent needs: it enumerates the output categories and explicitly ties the tool to pre-write safety checks. The absence of an output schema is adequately compensated by this detailed listing.

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

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

The input schema has zero parameters, so the baseline is 4. The description adds no parameter details, but none are needed. It instead clarifies what the returned data covers, which is more relevant here.

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

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

The description names the exact resource (protocol safety status) and enumerates its components: CircuitBreaker state and NFTVetoCouncil composition. This clearly distinguishes it from sibling tools like get_protocol_registry and the write-building 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?

It explicitly states when to use this tool: 'Critical context BEFORE sending any write'. It explains the consequence of not checking (writes revert if paused), though it does not mention alternative tools or when not to use it.

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

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

With no annotations, the description carries the full burden. It discloses the output type but does not explicitly state that the operation is read-only or describe any side effects, authentication requirements, or error conditions. The 'get' verb implies a safe read, but it's not spelled out.

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. It front-loads the action and resource, then uses an em-dash to list the specific data returned. Every word 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?

Given the tool's simplicity (one parameter, no output schema, no annotations), the description provides a good range of what the stats include. It partially compensates for the missing output schema by enumerating the returned fields, though it doesn't specify the return format or any pagination behavior.

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 has 100% coverage for the single 'address' parameter. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the verb 'Get' and the resource 'referral statistics' for a registered agent. It lists specific data points (total referrals, earnings, reward per burn, calldata for referred burns), distinguishing it from siblings like register_referral_agent or get_megachad_stats.

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 'for a registered agent' implies the tool is used after registration, but there is no explicit alternative or exclusion. It doesn't mention when to use this over other stats tools, leaving the context implied rather than explicit.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It specifies that the tool returns combined data across two venues, lists the key data points (balances, allowances, rewards, NFT boost, APR, global pool stats), and clarifies the global-stats-only behavior without an address. It doesn't mention non-mutating nature explicitly, but 'Returns' strongly implies 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 two sentences, with the first sentence front-loaded to state the core purpose and venues. The second sentence lists included data and the optional address behavior. Every word earns its place, with no redundant filler.

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

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

With no output schema, the description compensates by enumerating the returned data categories (balances, allowances, earned rewards, NFT boost, APR, global pool stats). It covers both invocation modes (with/without address) and gives enough context for an agent to call appropriately. Missing details like address format or error handling are minor for this simple read tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful parameter semantics by explaining the effect of omitting the address: 'Without address, returns global stats only.' This is not present in the schema, which only marks the parameter as optional.

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 ('Returns combined position') and specifies the resource: both MoggerStaking and JESTERGOONER V4 staking venues. It also differentiates from siblings by naming the exact venues and the tokens involved (MEGACHAD, MEGAGOONER, MC/MG LP), which no other sibling tool covers.

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 implicit usage guidance by explaining the two modes: with an address (per-wallet position) and without (global stats only). While it doesn't explicitly contrast with alternatives, the unique scope makes alternatives unnecessary. It also lists what data is included, helping the agent decide 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It adequately reveals what the tool returns (router address, calldata params, slippage-adjusted output) and the dual behavior depending on whether ethAmount is supplied. It does not explicitly state that this is a read-only quote with no execution side effects, but the term 'quote' implies that; the return field disclosure adds useful context.

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

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

The description is three sentences with no filler. The core action is front-loaded, and each sentence provides distinct information: the swap context, the return fields, and the omit behavior. It is appropriately sized for a simple, single-parameter tool.

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, the description sufficiently enumerates the primary return values (router address, calldata params, slippage-adjusted minimum). It also covers the optional parameter's behavior. For a tool with one optional parameter and no output schema, this is adequately complete for selection and invocation. It does not explain the calldata structure in depth, but that is beyond the description's necessary scope.

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

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

The schema already describes the single parameter ethAmount with 100% coverage, so the baseline is 3. The description adds slight value by clarifying that omitting ethAmount yields 'general swap info and contract addresses,' extending the schema's 'general info' phrase. This is a small but meaningful increment.

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 ('Get') and resource ('swap quote'), and further distinguishes itself by specifying the exact context: buying $MEGACHAD with ETH on Kumbaya DEX. It also lists the expected return values (router address, calldata params, slippage-adjusted minimum output), making the purpose concrete and differentiating it from sibling tools like get_amm_quote.

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 the main use case (buying MEGACHAD with ETH) and provides instruction on the optional ethAmount parameter ('Omit ethAmount for general swap info and contract addresses'). However, it does not explicitly compare to alternatives like get_amm_quote or build_amm_swap_tx, so some usage boundaries are implied rather than stated.

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

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

With no annotations, the description carries the full burden. It enumerates the exact data points returned (ETH balance, $MEGACHAD balance, NFT count, burn eligibility, early access status), which clearly discloses the tool's behavior. It implies a read-only operation, though it does not explicitly mention lack of side effects or authentication 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 a single, information-dense sentence that lists all key outputs without filler. It is front-loaded and every word 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 simple read-only tool with one parameter and no output schema, the description lists all expected return values, which effectively serves as the output specification. It lacks notes on edge cases or confirmation of output format, but is complete enough for most usage scenarios.

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

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

The input schema has 100% coverage with the description 'Ethereum wallet address (0x...)' for the only parameter. The tool description does not add additional semantics beyond referencing the wallet, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Check a wallet's ETH balance, $MEGACHAD balance, NFT count, burn eligibility, and early access status.' It uses a specific verb and resource, but does not differentiate from siblings like get_portfolio or get_nft_inventory, so it lacks explicit sibling 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 provides no guidance on when to use this tool versus alternatives. It does not mention any specific scenarios, exclusions, or alternative tools, leaving the agent without contextual selection criteria.

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 the exact content of the list (state, vote tallies, timing, URLs) and implies a read-only operation. It does not mention pagination, ordering, or potential errors, but for a simple list tool this is adequate.

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

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

A single, well-structured sentence packs all essential information without waste. It front-loads the primary action and resource, then lists specifics.

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

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

With no output schema, the description compensates by enumerating the returned fields. 'Recent' is somewhat vague, but the limit parameter and per-proposal URLs provide enough context for a low-complexity list 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 sole parameter 'limit' is fully documented in the schema (type, min, max, default), so the description adds no additional semantic value. Per the rubric, baseline is 3 when schema coverage is high.

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 action ('List'), the resource ('recent Jestermogger governance proposals'), and the specific details returned (state, vote tallies, timing, URLs). This distinguishes it from sibling get_governance_proposal, which retrieves a single proposal.

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 tool is for browsing recent proposals and provides per-proposal URLs for further lookup, but it does not explicitly name alternatives like get_governance_proposal for single-proposal details. The context is clear, though exclusion guidance is absent.

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 behavioral burden. It discloses that eligibility is checked via $MEGACHAD balance or specific NFTs, and that it returns a referral code and access status. However, it lacks details about side effects (e.g., persistence, reversibility), failure modes, or whether a signature is required.

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 long, front-loaded with the primary action and purpose, followed by eligibility and return details. No wasted words; every clause 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 no output schema, the description usefully mentions return values (referral code and access status) and explains the eligibility criteria. It covers the essential decision-making context for an agent, though it omits edge cases like ineligible wallets or error behavior. For a straightforward registration tool, 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?

Schema coverage is 100% with concise descriptions for all three parameters. The main description adds minimal extra meaning about parameters, though it mentions returning a referral code, which may also be an input. The baseline of 3 is appropriate because the schema 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 clearly states the action ('Register a wallet for MegaChad testnet beta access') with a specific verb, resource, and purpose. It also distinguishes itself from sibling tools like register_referral_agent by focusing on testnet access eligibility and referral code/status output.

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 intended use case is implied: registering for early access after an on-chain eligibility check. However, it does not explicitly compare with alternatives or state when not to use this tool (e.g., versus register_referral_agent). No exclusions or conditions are provided.

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 return values (transaction calldata and referral code) and the reward mechanism, but does not explicitly state that it only builds calldata and does not submit a transaction, nor does it mention any prerequisites or side effects.

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

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

Three sentences, each earning its place: purpose, output, incentive. 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 three simple parameters and no output schema, the description covers the essential aspects: what it does, what it returns, and the reward context. It lacks explicit note on transaction execution, but the mention of 'returns calldata' implicitly indicates a build-only operation.

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

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

The input schema provides full descriptions for all three parameters (100% coverage), so the description need not elaborate. The description does not add parameter-level detail, but the schema already handles that.

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 'Register' and identifies the resource ('a wallet as a MegaChad referring agent'), clearly distinguishing it from sibling tools like register_early_access. It also states the output (calldata and referral code).

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 implies when to use the tool (to register as a referral agent) but does not provide explicit guidance on alternatives or when not to use it. The sibling register_early_access is not referenced, so no comparison is offered.

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