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 behavioral traits: it returns source code formatted as a Markdown code block and does not write to disk. It also mentions deployability and extensibility. This goes beyond basic 'generate contract' and provides useful operational details, though it does not cover potential errors or prerequisites.

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

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

The description is concise with two short paragraphs. The first sentence states the core purpose, and the second paragraph clarifies the return format and side effects. There is minor redundancy (e.g., 'custom smart contract' and 'account' explanation), but overall it is well-structured and front-loaded without excessive wordiness.

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

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

Given the tool's complexity (9 parameters, nested objects, no output schema), the description covers the essential missing pieces: it states the return format (Markdown code block) and non-disk-write behavior. The schema covers parameter meanings. However, it does not address edge cases or limitations, and it lacks explicit differentiation from sibling code generators, leaving some contextual ambiguity. Still, it is reasonably complete for an agent to invoke the tool correctly.

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

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

The input schema has 100% description coverage for all 9 parameters, so the schema already explains each parameter. The description itself adds no additional parameter-specific semantics beyond what the schema provides. The baseline is 3 because the schema does the heavy lifting and the description does not need to compensate.

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

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

The description clearly states the verb 'Make' and the resource 'a custom smart contract that represents an account'. It distinguishes itself from sibling tools by focusing specifically on account contracts, though it does not explicitly name alternatives like cairo-custom or cairo-multisig. The purpose is specific enough for an agent to understand this generates account contract source 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 provides context by explaining that an account is a special type of contract for validating and executing transactions, which implies when this tool is relevant. However, it does not explicitly state when to prefer this over sibling tools such as cairo-multisig or cairo-governor, nor does it mention any exclusions. Usage guidance is implied rather than explicit.

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

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

Even though annotations are absent, the description discloses critical behaviors: it returns source code, formats it as Markdown, and does not write to disk. This transparently signals a side-effect-free generation process. It stops short of mentioning more subtle behaviors (e.g., output length or dependency on network), but is strong for a code generator.

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

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

The description is exceptionally concise: two sentences convey purpose, return format, and side-effect involvement. Every phrase adds value, with the key information front-loaded.

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

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

For a code-generation tool, the description covers the essential behaviors: what it does, what it returns, and what it doesn't do (write to disk). The input schema fully documents parameters, and no output schema is present, so the text appropriately focuses on the generation outcome. It could mention deployment explicitly, but that is reasonably implied by 'returns source code.'

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 high (83%) and includes detailed explanations for nested objects like 'access' and 'macros'. The description adds no parameter-specific context beyond the schema, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's function ('Make a custom smart contract') and explicitly notes the output (source code in a Markdown code block). The term 'custom' distinguishes it from the sibling template-based tools, making its unique role clear.

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

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

No explicit guidance is given on when to choose this tool over siblings like cairo-erc20 or cairo-governor. The word 'custom' implies a fallback for non-standard contracts, but the description never states criteria, 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 must carry behavioral disclosure. It states the tool returns Markdown-formatted source code and does not write to disk, which are important side-effect facts. However, it doesn't disclose other behaviors like network calls, compilation, or whether it's purely deterministic. For a code-generation tool, the disclosed behavior is adequate 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 extremely concise: two short sentences with no filler. It front-loads the core purpose and then states the two most operationally relevant behaviors (output format and no disk write). 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?

Despite having 13 parameters, nested objects, and no output schema, the description is minimal. It does not explain how to choose this tool over near-identical siblings (e.g., solidity-erc1155 or cairo-erc721), nor does it hint at what a successful response contains beyond a code block. The schema covers parameter details, but the description lacks usage context and integration guidance, making it insufficient for a tool with this complexity.

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

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

Schema description coverage is 92%, so the schema documents most parameters. The description adds no parameter-specific meaning beyond what the schema already provides. It does not explain how the numerous boolean flags interact or what the nested objects control, but the high coverage makes the schema the primary source. Baseline 3 is appropriate.

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

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

The description clearly states it creates an ERC-1155 non-fungible token and returns source code. The verb 'Make' is specific, and the resource (ERC-1155 standard) is clear. It distinguishes from ERC-20/ERC-721 siblings, though it doesn't explicitly say this is for Cairo (relying on the tool name).

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

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

No guidance is provided on when to use this tool versus alternatives like solidity-erc1155 or cairo-erc721. There is no mention of context, prerequisites, or exclusions. The description does not help an agent decide between this and sibling code generators.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It usefully states that the tool returns source code in a Markdown code block and explicitly notes it does not write to disk, which clarifies side effects and output format. It does not mention every edge behavior, but the key safety-relevant behavior is disclosed.

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 and every sentence adds value: the first states the purpose, and the second clarifies output format and side-effect behavior. It is front-loaded with the core purpose and contains no fluff.

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

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

Given the tool's complexity, the description covers the essential context: what it generates, how the result is returned, and that it has no filesystem side effect. The extensive input schema covers parameter details, so the description does not need to repeat them. A brief note about language/platform fit could improve completeness, but the tool name supplies that 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 description coverage is 94%, so the parameter schemas already carry detailed explanations for most options. The tool description itself adds no parameter-level semantics, which is acceptable but does not go beyond what the schema provides.

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

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

The description states a specific action and resource: 'Make a fungible token per the ERC-20 standard.' This clearly differentiates it from non-fungible siblings like cairo-erc721 and cairo-erc1155. However, it does not explicitly distinguish it from other ERC-20 sibling tools in different languages, relying on the tool name for that distinction.

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 context is implied: use this tool when an ERC-20 fungible token contract source is needed. There is no explicit guidance about when to prefer cairo-erc20 over solidity-erc20, stylus-erc20, or tron-trc20, nor any stated 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 provided, the description carries the full burden of behavioral disclosure. It specifies that the tool returns source code in a Markdown block and does not write to disk, which are essential behaviors. However, it does not mention any potential side effects beyond that, but for a code generator these two are the most critical.

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 concise sentences with no filler. The purpose is front-loaded, and the behavioral note about output and disk usage adds value without redundancy.

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

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

For a tool with 11 parameters and nested objects, the description covers the core purpose, output format, and side-effect avoidance. It does not clarify the interaction between 'minimal' and the optional features, but the schema descriptions cover each parameter adequately. Overall, it is sufficiently complete for an agent to call it correctly.

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

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

The schema description coverage is 91%, so the parameters are well-documented in the schema itself. The description adds no extra meaning to parameters, only the general notion of 'minimal' which might be ambiguous. Baseline 3 is appropriate given the high coverage.

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

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

The description clearly states the action ('Make a minimal multi-token') and the specific standard (ERC-6909), which distinguishes it from sibling tools like cairo-erc20 and cairo-erc721. It also clarifies that it returns source code, removing any ambiguity about being a generator.

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 ERC-6909 tokens via the standard name, but it does not explicitly mention when to choose this tool over alternatives or provide exclusions. Since siblings cover other standards, the guidance is only 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 behavioral burden. It does this well by disclosing the output format ('formatted in a Markdown code block') and explicitly stating 'Does not write to disk,' which clarifies the tool is a non-persistent source-code generator. It does not cover behavior on invalid or conflicting parameters, but the core side-effect profile is transparent.

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

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

The description is two sentences with no filler: it front-loads the purpose, then states the return format and side-effect behavior. Every sentence adds distinct value.

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

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

For a code-generation tool with a rich input schema and no output schema, the description supplies the missing pieces: return format and lack of disk writes. It does not explicitly mention the target chain/language in the description, but the tool name and title cover that context. All functional parameters are already explained in 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 description coverage is high (94%), so the input schema already provides strong parameter-level meaning. The description adds no parameter-specific details, which is acceptable under the high-coverage baseline of 3.

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

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

The description uses a specific verb and resource: 'Make a non-fungible token per the ERC-721 standard,' and clarifies that it returns contract source code. It distinguishes the tool from ERC-20/ERC-1155 siblings by naming the standard, though it does not explicitly state 'Cairo' or reference sibling Solidity/Stylus ERC-721 tools, leaving some differentiation to the tool title/name.

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

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

There is no guidance about when to use this tool versus alternatives such as solidity-erc721, stylus-erc721, or cairo-erc1155. No conditions, exclusions, or explicit alternative selection hints are provided; usage is only implied by the tool name and the ERC-721 standard mention.

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 transparently states that the tool returns source code formatted as a Markdown code block and explicitly says it does not write to disk. This is valuable context about side effects and output format, though it does not cover every possible behavioral nuance.

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 tool's purpose, and immediately follows with the key output behavior. Every sentence provides necessary information 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?

Given the tool's complexity (17 parameters, nested objects, no output schema), the description covers the essential contextual points: what it generates, the output format, and its non-destructive behavior. The absence of details about parameter interactions is mitigated by the rich schema descriptions. It is slightly lean for such a complex tool but still adequate.

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 fully documents all 17 parameters. The description adds no parameter-specific meaning, which is acceptable given the high schema coverage. The baseline of 3 applies because the schema handles 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 a specific action: 'Make a contract to implement governance, such as for a DAO.' It also clarifies the output by noting it returns source code in a Markdown code block. This distinguishes the tool from sibling contract generators like cairo-erc20 or cairo-account by its governance focus.

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 'such as for a DAO' implies a governance use case, but no explicit comparison with alternatives or exclusions is provided. While the sibling tool names suggest other contract types, the description itself does not state when to prefer this tool over them.

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

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

With no annotations, the description provides crucial behavioral context: it returns source code in a Markdown code block and does not write to disk. This explicitly states the tool's side-effect-free nature, which is valuable for an agent deciding whether to invoke it. It doesn't mention input validation or edge cases, but for a code generator this is sufficient.

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

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

Two sentences, no filler, front-loaded with the core purpose. Each sentence adds value: the first states what the tool does, and the second clarifies the output format and side effects. Excellent conciseness.

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 code generation tool with 5 parameters and no output schema, the description provides the essential context: what it does, the output format, and that it doesn't write to disk. The schema covers parameter details, so the description is complete enough without explaining every field.

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?

All 5 parameters are documented in the schema (100% coverage), so the description adds little beyond the schema. The mention of quorum and signers provides some additional context, but the baseline of 3 is appropriate since the schema does the heavy lifting.

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

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

The description uses a specific verb ('Make') and resource ('multi-signature smart contract'), clearly distinguishing it from sibling contract generators. It also adds key details like quorum and signers, making the purpose unmistakable.

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

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

The context is clear (generating a multisig contract), but there is no explicit guidance on when to choose this over alternatives like cairo-governor or cairo-custom. It implies usage but lacks when-not or alternative recommendations.

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

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

With no annotations provided, the description carries the full burden. It discloses two important behaviors: the output is rendered as a Markdown code block and it does not write to disk. This goes beyond the basic purpose and gives the agent a clear picture of side-effects and return format, though it does not cover error cases or permission requirements.

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

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

The description is two sentences: the first states the purpose, the second states the output and side-effect. It is front-loaded, concise, and every sentence earns its place with no redundant 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?

The combination of the description and a very detailed input schema provides a solid understanding of the tool. The output format and non-persistence behavior are clearly specified. However, the description mentions a 'designated beneficiary' which is not represented as a parameter in the schema, creating a minor gap about how the beneficiary is configured. Otherwise, it is complete for a code generation 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 all parameters are already described in detail (formats, enums, defaults). The description adds no additional parameter-specific meaning, only referencing a 'predefined vesting schedule' without elaborating on the schedule option. Baseline of 3 is appropriate because 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?

Purpose is highly specific: 'Make a vesting smart contract that manages the gradual release of ERC-20 tokens to a designated beneficiary based on a predefined vesting schedule.' This clearly distinguishes it from sibling contract generators (e.g., erc20, erc721) and includes the output format (Markdown source code) and side-effect (no disk write).

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 a vesting contract is needed), but it does not explicitly mention alternatives or exclusion criteria. Since sibling tools are all different contract types, the usage is clear by context but not explicitly stated, resulting in an implied rather than explicit guideline.

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 clearly states the output behavior ('Returns the source code... formatted in a Markdown code block') and side-effect freedom ('Does not write to disk'). This adds valuable context beyond the schema, though it doesn't cover potential errors or auth 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 highly concise, containing only two sentences that front-load the core purpose and immediately follow with output/behavior details. Every sentence earns its place with no extraneous content.

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 9 parameters, the schema compensates with rich descriptions. The description sufficiently covers the tool's function (generation, not deployment) and output format, and explicitly notes it does not write to disk. This provides enough context for selection and invocation, though it omits advanced details like dependencies or verification steps.

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 does not add additional meaning to parameters beyond what the schema already provides; it only mentions the token is confidential and similar to ERC-20, which is general context rather than parameter-specific clarification.

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 'Make a confidential fungible token in Solidity according to the ERC-7984 standard,' which clearly identifies the action (make/generate) and resource (confidential token contract). It also distinguishes from sibling tools like solidity-erc20 by highlighting the confidentiality aspect, making the purpose unambiguous.

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

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

The description implies usage for confidential tokens ('similar to ERC-20 but with confidentiality'), but it does not explicitly state when to use this tool over alternatives, nor does it mention exclusions or contrast with any specific sibling tool. Usage guidance is only implicit, not directly 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 of disclosure. It does reveal that the tool returns source code in a Markdown code block and does not write to disk, which is useful behavioral information. However, it does not mention any other nuances such as error handling or parameter-driven behavior changes, resulting in a moderate level of transparency.

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

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

The description is three short, focused sentences. It is front-loaded with the purpose, followed by the return format and a key side effect, 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?

For a tool with 9 parameters and no output schema, the description is brief but covers the essential aspects: what it creates, the format of the result, and that it does not write to disk. Given the rich schema descriptions, the tool is adequately contextualized for correct invocation.

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

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

Schema coverage is 100% and every property has a detailed description (e.g., signer enum options, upgradeable types, ERC-721/1155 holders). The description itself adds no parameter-level meaning, but the schema compensates fully, so the baseline score of 3 is appropriate.

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

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

The description begins with 'Make an account contract that follows the ERC-4337 standard,' which clearly states the action and resource. It also specifies the output format (Markdown code block) and the side effect (does not write to disk), distinguishing it from sibling contract generators by scope and behavior.

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 frames the tool as for generating an ERC-4337 compliant account contract, implying when it should be used. However, it does not explicitly name alternative tools or state exclusions, so it falls short of an explicit when/when-not guide.

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?

Since no annotations are provided, the description carries the full burden. It transparently discloses that the tool returns source code in a Markdown code block and does not write to disk, which is key behavioral information for a code-generation tool.

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

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

The description is two short sentences, front-loading the core purpose and immediately adding return format and side-effect information. Every sentence earns its place without redundancy.

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

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

The description provides the essential context: purpose, output format, and no disk writes. Given the detailed input schema, this is mostly complete, though it could be slightly richer about how parameters shape the generated contract.

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

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

The input schema covers all parameters (100%) with detailed descriptions for name, info, access, pausable, and upgradeable. The description itself adds no parameter-specific detail, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's function: 'Make a custom smart contract.' It also specifies the output (source code in a Markdown code block), and the word 'custom' distinguishes it from sibling tools like solidity-erc20 or solidity-erc721.

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

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

No explicit when-to-use or alternative guidance is provided. The word 'custom' implies it is for bespoke contracts rather than standard templates, but there are no clear conditions, prerequisites, or exclusions.

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

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

No annotations are provided, so the description carries the full behavioral burden. It explicitly states that the tool returns source code formatted as a Markdown code block and does not write to disk, which are key behavioral and side-effect guarantees for a code generation 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 concise sentences: the first states the purpose and the second states the output format plus the key side-effect limitation. Every sentence earns its place with no redundancy or filler.

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

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

For a 12-parameter generator with no output schema and no annotations, the description adequately covers what is returned and that nothing is written to disk, while the schema covers all parameter semantics. It is nearly complete, though explicitly naming Solidity in the description would improve standalone clarity.

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

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

Schema description coverage is 100%, and the schema already provides detailed field-level explanations for all 12 parameters. The description adds no parameter-specific detail, so the baseline score for schema-covered parameters applies.

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

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

The description uses a specific verb ('Make') and a clear resource ('a non-fungible token per the ERC-1155 standard'), and clarifies that it returns generated source code. It distinguishes from unrelated generator tools, but it does not explicitly name Solidity or contrast with the Cairo/Stylus ERC-1155 siblings.

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

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

There is no when-to-use guidance or mention of alternatives. The description only states what the tool generates; it does not help the agent decide between this and sibling tools such as solidity-erc721, stylus-erc1155, or cairo-erc1155 beyond relying on the tool name.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It clearly states that the tool returns source code in a Markdown code block and does not write to disk, which are important side-effect details for an agent. It omits deeper information about edge cases or errors, but the core behavior is transparent.

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

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

The description is two concise sentences that front-load purpose and immediately state return format and side-effect behavior. Every sentence earns its place with no filler.

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

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

For a highly parameterized tool with 18 inputs and no output schema, the description is minimal but does cover the key return value and side-effect profile. It does not compensate for the absence of annotations or explain how the generator fits among sibling Solidity/Cairo/stylus tools, leaving the context 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%, so the rich per-parameter descriptions already carry most of the semantic weight. The tool description itself adds little about parameters beyond 'per the ERC-20 standard', so it meets the baseline but does not go further.

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

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

The description says 'Make a fungible token per the ERC-20 standard', which is a clear verb plus resource, and the title/name make the Solidity context obvious. However, it does not explicitly distinguish itself from siblings such as solidity-stablecoin, solidity-rwa, or cairo-erc20.

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

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

There is no guidance about when to use this tool versus the many sibling generators. The description does not state alternatives, exclusions, or prerequisites, so an agent must infer usage from the tool name alone.

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?

Since no annotations are provided, the description carries the behavioral disclosure burden. It explicitly states the output is source code formatted as a Markdown code block and that it does not write to disk, which is valuable side-effect information beyond what the schema could convey.

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

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

The description is two short sentences: the first states the core purpose and the second covers the output format and key side-effect. Every sentence earns its place and there is no filler or restatement of the tool name.

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 code-generation tool with a well-described 16-parameter schema but no output schema, the description adequately covers the return value and side effects. It explains what the agent will receive, how it is formatted, and that nothing is persisted, which is sufficient for agent judgment.

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

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

The schema already provides descriptions for 100% of the 16 parameters, so the tool description does not need to repeat them. The description adds no specific parameter-level guidance, but the schema itself is sufficient, so the baseline score of 3 applies.

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

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

The description clearly states the tool generates a non-fungible token according to the ERC-721 standard, and it clarifies that the result is source code rather than a deployed asset. This is specific enough to distinguish it from the many ERC-20, ERC-1155, Cairo, and Stylus siblings.

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

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

The description implies the tool should be used when ERC-721 contract source is needed, but it does not explicitly say when to use it versus alternatives like solidity-erc1155, cairo-erc721, or solidity-custom. There is no when-not-to-use guidance or mention of sibling 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 full burden for behavioral disclosure. It explicitly states the tool returns source code in a Markdown code block and does not write to disk, which are critical side-effect and output behaviors. This gives the agent a clear understanding of the tool's non-mutating, generation-only nature, although it doesn't detail potential errors or dependencies.

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 short sentences, each earning its place: the first establishes purpose, the second specifies the return format, and the third clarifies a key side-effect (does not write to disk). It is front-loaded with the core purpose and contains no filler or irrelevant 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?

Despite the tool's complexity (17 parameters, nested objects, no output schema), the description covers the essential aspects: purpose, output format, and side-effect behavior. The schema handles parameter details, so the description need not repeat them. It could have added more about the generated contract's structure or usage examples, but it is sufficiently complete for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description itself adds no parameter details, but the input schema already provides comprehensive descriptions for all 17 parameters. The description does not need to compensate, and no value is added 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's function: 'Make a contract to implement governance, such as for a DAO.' It identifies the specific resource (governance contract) and the action (generate). The phrase 'such as for a DAO' and the return format ('Returns the source code...') distinguish it from sibling contract generators like solidity-erc20 or solidity-account.

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

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

The description provides clear context: use this tool when you need to generate a governance/DAO contract. It implies the use case without explicitly naming alternatives, but the purpose is specific enough that an agent can infer when to choose it over sibling contract generators. No exclusions are given, but the context is unambiguous.

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

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

Given the absence of annotations, the description carries the full burden and does a good job: it states the tool does not write to disk and returns source code in a Markdown block. The experimental, unaudited nature of some features is disclosed multiple times in the schema, and while the description mentions it, the specifics about which features are experimental are only in the schema. The description is honest that some features are experimental and subject to change, providing critical 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 minimal and to the point, consisting of only three sentences that efficiently convey the core purpose and critical experimental caveat while front-loading the main value proposition.

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 highly complex tool with 19 parameters and nested objects, the description is quite minimal. The schema and parameter descriptions are rich, but the description does not explain the overall workflow or the contract's architecture, nor does it provide an overview of what the generated code looks like. No output schema exists to fill in gaps, so the description could have been more complete about the tool's overall behavior, making its output a contract source file.

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

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

The schema has 100% description coverage, so the baseline is 3, but the description adds zero information about how parameters shape the generated contract. With 19 parameters, the description's silence on how the schema parameters configure the output and the impact of those choices is a miss. The description also doesn't clarify the meaning of higher-level interactions like votes and crossChainBridging or the tradeoffs, though the schema itself is thorough.

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 makes an ERC-20 real-world asset token, though the term 'real-world asset token' is a bit unusual and could benefit from more specificity. The description differentiates it as experimental and clarifies the output is source code in a Markdown block, which helps distinguish it from sibling tools like solidity-erc20 by focusing on the real-world asset aspect.

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 the user wants to create an ERC-20 RWA token, but does not explicitly explain when to choose this over siblings like solidity-erc20. No alternative tools are named, and the differences are left implied. The experimental warning provides some context for when caution is needed, but it is minimal.

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 explicitly states that the tool returns generated source code as a Markdown code block and does not write to disk, which are crucial behavioral details. It also warns that the tool is experimental. Minor gaps remain around error conditions or output characteristics.

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 highly concise and front-loaded, stating purpose and major caveat in the first sentence, then returning behavior in a compact second paragraph. Every sentence earns its place with no redundancy.

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

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

Given the tool's complexity (19 parameters, nested objects, no output schema), the description is adequate but sparse. It covers output format and non-persistence, and the schema covers parameters, but it omits an overview of how stablecoin-specific options relate to the tool's purpose and how this tool compares to sibling ERC-20 generators.

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 tool description itself adds no parameter-level meaning; it relies entirely on the schema for parameter semantics.

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

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

The description clearly states the tool's function: generating a stablecoin token using the ERC-20 standard. However, it does not differentiate from sibling tools like solidity-erc20 or solidity-custom, missing the top score.

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

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

No guidance is provided on when to use this tool versus alternatives such as solidity-erc20 or solidity-rwa. Prerequisites, exclusions, and trade-offs are not mentioned; the experimental warning is a caveat, not usage direction.

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 side effects. It explicitly states that the tool 'Returns the source code of the generated contract, formatted in a Markdown code block' and 'Does not write to disk', which are critical behavioral traits. It does not mention permissions, network access, or potential errors, but for a code generator, these are less relevant. The description adequately signals that no persistent changes are made.

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

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

The description is extremely concise, consisting of only two short paragraphs. It front-loads the primary purpose, then immediately discloses the output format and lack of disk write. Every sentence contributes essential information without redundant phrases. This is an ideal example of efficient writing.

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

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

Given the tool's complexity (8 parameters, nested objects, no output schema), the description covers the core purpose and output format. Since the schema already documents all parameters in detail (100% coverage), the description does not need to repeat those. It provides a use-case example and side-effect transparency, which are the missing pieces. It could be more complete by mentioning that policy contracts are required for threshold policies, but that is already in the schema. Overall, it is adequate for an agent to 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?

Schema description coverage is 100%, so the baseline is 3. The description adds a meaningful example ('multisig with passkey, Ed25519 and delegated signers') that illustrates how parameters like webauthnSigners, ed25519Signers, and delegatedSigners interact, but it does not provide additional semantics beyond what the schema already documents. This is sufficient, but not above the baseline.

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

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

The description clearly states the tool's purpose: to generate a smart account contract on Stellar with configurable signers and policies. It provides a concrete example (multisig with passkey, Ed25519, and delegated signers) and distinguishes it from sibling tools like stellar-fungible or stellar-governor by its focus on account contracts. The verb 'Make' combined with the resource 'smart account contract' is specific.

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 you need a Stellar smart account with specific authorization logic. It gives an example of multisig use cases, which suggests typical scenarios. However, it does not explicitly mention when NOT to use it or compare it to alternatives (e.g., 'for a simpler account, use X'). Still, the context from sibling names and the description's clarity provide sufficient guidance for most cases.

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 key behaviors: 'Returns the source code of the generated contract, formatted in a Markdown code block' and 'Does not write to disk.' This explains the output format and side-effect absence, which is critical for a generator. However, it does not mention validation, error handling, or whether parameters have constraints beyond the schema, so some transparency is still missing.

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

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

The description is extremely concise, two sentences long, with the purpose front-loaded. Every sentence serves a distinct function: the first states what the tool creates, and the second explains the output format and side-effect. There is no wasted wording or repetition of schema 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?

Given the tool's complexity (12 parameters, no output schema), the description covers the essential context: it generates a contract, returns source code, and does not write to disk. It does not explain the meaning of specific parameter combinations or error conditions, but the rich schema descriptions compensate. The description is sufficient for an agent to understand the tool's role and primary 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?

Schema coverage is 100%, with every parameter having a description in the input schema. The tool description does not add additional meaning beyond what the schema provides; it only mentions the fungible token standard, which is already implied. The description neither clarifies ambiguous parameters nor provides usage examples, so it adds marginal value over the schema.

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

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

The description clearly states it 'Make a fungible token per the Fungible Token Standard, compatible with SEP-41', which is a specific verb and resource. It distinguishes from siblings by explicitly naming the token standard and noting it is 'similar to ERC-20'. The addition that it returns source code and does not write to disk further clarifies its role as a code generator.

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 through its focus on fungible tokens and SEP-41 compatibility, but it does not explicitly mention when to use this tool versus alternatives like stellar-non-fungible or stellar-stablecoin. No exclusions or alternative tool references are provided. The context is clear but guidance is only implied, not 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 of behavioral disclosure. It explicitly states that the tool returns source code in a Markdown block and does not write to disk, which are key safety and behavior clarifications. However, it does not mention other potential side effects, required permissions, or failure modes, so it falls short of a perfect score.

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 clear sentences, front-loaded with the core purpose and ending with essential output/behavior info. Every word earns its place with no redundancy or filler.

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

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

The description covers the tool's primary function and output format. Although there is no output schema, the description explains the return format. It does not discuss parameter interactions or edge cases, but the schema provides parameter-level detail. Given the complexity (11 params, nested objects), slightly more context about the generated contract could be beneficial, but the description is still largely complete.

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

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

The input schema provides complete descriptions (100% coverage) for all 11 parameters, so baseline is 3. The description does not add any additional parameter semantics, but given the strong schema, this is acceptable.

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 action ('Make'), the resource ('governor contract'), and the specific domain ('on-chain governance using token-based voting'). This distinguishes it from sibling tools that generate other contract types (fungible, non-fungible, stablecoin, vault).

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that it should be chosen when creating a governance contract, nor does it exclude other scenarios. Sibling names imply different contract types, but the description itself lacks explicit usage direction.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly states the output format ('source code... in a Markdown code block') and the action of not writing to disk, which informs the agent that this is a non-persistent generation operation. This goes beyond mere purpose and adds safety-relevant 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 long, with the first stating the purpose and the second covering return format and side-effect. Every sentence is informative 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 absence of an output schema, the description usefully specifies that the return is a Markdown code block containing source code. It also orients the user with the 'similar to ERC-721' analogy, which helps set expectations for the contract structure. However, it doesn't address error conditions or prerequisites beyond schema requirements.

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

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

The input schema has 100% description coverage for all 14 parameters, so the baseline is 3. The description does not add any extra meaning to parameters beyond what the schema already provides.

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

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

The description clearly states the tool's function with a specific verb ('Make') and resource ('non-fungible token'), further defined by the Non-Fungible Token Standard and SEP-50 compatibility. This distinguishes it from sibling tools like stellar-fungible, satisfying the specificity requirement.

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 its use case by specifying 'non-fungible token' and the standard, but it does not explicitly mention when to use it over alternatives or provide exclusions. The sibling tool names provide context, but the description itself offers no comparative guidance, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It clearly states that the tool returns source code as a Markdown block and does not write to disk, which sets expectations about side effects. However, it does not disclose any other behaviors such as network calls or permissions, but for a code generator this is sufficient.

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

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

The description is exceptionally concise: three short sentences that lead with the purpose and then detail the output format and side-effect behavior. Every sentence earns its place, and there is no redundant 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?

The description covers the key contextual aspects: what the tool does, what it returns, and that it is non-persistent. While the tool has 13 parameters, the schema provides full descriptions, so the description does not need to elaborate on each. It adequately equips an agent to decide whether to invoke this tool within the given 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 coverage is 100%, so the baseline is 3. The description does not add parameter-level meaning beyond what the schema already provides for each of the 13 parameters. It neither compensates for gaps nor adds special context, but it does not need to.

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

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

The description clearly states the tool's purpose: to create a stablecoin using the Fungible Token Standard and SEP-41. The verb 'Make' combined with the specific resource 'stablecoin' leaves no ambiguity. It differentiates from sibling tools by specifying 'stablecoin' rather than generic fungible tokens, non-fungible, or governor tokens.

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 generating stablecoin contracts but does not explicitly state when to use it over alternatives like stellar-fungible or stellar-governor. There is no mention of exclusions or recommended scenarios, so the usage guidance is only 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 transparency burden. It clearly discloses that the tool returns source code and does not write to disk, which is essential behavioral context. It does not mention any other side effects or limitations, but for a code generator this disclosure is substantial.

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

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

The description is two sentences: the first states the core purpose, the second specifies the output format and side-effect. It is concise, front-loaded, and every sentence earns its place.

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

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

For a complex generator with 8 parameters and no output schema, the description covers the essential context: what the tool creates, its output format, and that it does not persist files. It leaves parameter details to the schema, which is fully described. Minor gap: no guidance on how parameter choices affect the generated contract, but this is not critical given schema coverage.

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

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

Schema description coverage is 100%, so the schema fully documents all 8 parameters. The description adds no additional parameter-level semantics, which aligns with the baseline of 3 for high coverage.

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

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

The description uses a specific verb 'Make' and a specific resource 'tokenized vault' that issues Fungible Token shares, clearly distinguishing it from sibling tools like stellar-fungible or stellar-governor. It also clarifies the output (source code in Markdown) and side-effect-free nature, leaving no ambiguity about what the tool does.

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

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

The description provides clear context by comparing to ERC-4626, implying it is for vault-style tokenized assets rather than simple tokens. However, it does not explicitly name alternatives or state when not to use this tool, so it falls short of full exclusionary guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states that the tool returns source code in a Markdown code block and does not write to disk, which informs the agent of the output format and lack of side effects. It does not mention other behavioral aspects like rate limits or errors, but for a code generation tool 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 remarkably concise: two sentences that deliver the core purpose and key behavioral details. It is front-loaded with the main action and directly states the output and side-effect. 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 description provides the essential context for using the tool: it generates an ERC-1155 contract and returns the source code without persisting to disk. The input schema covers parameters, and the lack of an output schema is compensated by the explicit note about Markdown formatting. It could mention the specific language/framework (Stylus implies Rust/Arbitrum) but the title already conveys that.

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 all four parameters documented in the input schema. The description itself adds no parameter-level detail 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 clearly states the tool's function: "Make a non-fungible token per the ERC-1155 standard." The verb is specific (Make), the resource is explicit (non-fungible token per ERC-1155), and it distinguishes itself from sibling tools by naming the standard. It also clarifies the output format, further reinforcing what the tool does.

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 by referencing the ERC-1155 standard, which contrasts with siblings stylus-erc20 and stylus-erc721. It does not include explicit when-not-to-use or alternative recommendations, but the naming of the standard provides clear context for selection.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly states that the tool returns source code in a Markdown code block and that it 'does not write to disk,' providing clear side-effect information. This goes beyond a bare schema and addresses key behavioral aspects.

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: the first states the primary purpose, and the second covers output and side effects. Every word is purposeful, with no redundancy or irrelevant 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?

The description fully explains what the tool generates, the output format, and that it does not write to disk. Combined with the schema's 100% parameter coverage and the presence of all necessary context, no critical information is missing.

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

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

The schema covers 100% of parameters with individual descriptions, so the description need not add detail. It provides no additional parameter semantics, but the schema already does the heavy lifting, justifying the baseline score of 3.

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

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

The description starts with 'Make a fungible token per the ERC-20 standard,' naming both the resource (fungible token) and specific standard, which clearly distinguishes it from sibling tools for ERC-1155 and ERC-721. It also clarifies the output ('Returns the source code of the generated contract'), removing any ambiguity about what 'make' entails.

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

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

The description explicitly states the ERC-20 standard, giving clear context for when to use this tool (for ERC-20 token source generation). However, it does not explicitly contrast with siblings or state when not to use it, so it falls short of a 5.

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

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

No annotations are provided, so the description carries the full burden. It explicitly states that the output is source code formatted in a Markdown code block and that the tool does not write to disk, which is a key side-effect disclosure. However, it does not mention authentication requirements or any potential failures, though those are less critical for a code generation tool.

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

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

The description is two efficient sentences. The first sentence states the core function, and the second covers the output format and the explicit lack of disk writes. There is no wasted wording or repetition of schema 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 code generation tool with a simple purpose, the description is complete: it explains what is produced, how it is returned, and what is not done. The parameters are fully documented in the schema, and the description covers return format since no output schema exists. The only minor gap is not mentioning the nested info object, but the schema handles that.

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

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

The schema has 100% description coverage for all 4 parameters, so the baseline is 3. The description adds no parameter-specific guidance, but none is needed because the schema already thoroughly explains each parameter, including the nested info object and its properties.

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

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

The description opens with a specific verb 'Make' and clearly specifies the resource: a non-fungible token per the ERC-721 standard. This immediately distinguishes it from sibling tools stylus-erc20 (fungible) and stylus-erc1155 (multi-token standard).

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 generating ERC-721 token source code but does not explicitly state when to choose this over the sibling tools or mention any exclusions. No reference to alternatives is made, leaving the selection decision to inference from the tool name and standard.

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 usefully states that the tool returns source code formatted as a Markdown code block and that it does not write to disk. This gives an agent a clear expectation of side effects and output format, though it does not mention broader behaviors such as whether any deployment or network interaction occurs.

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 concise sentences, front-loading the main purpose and immediately following with the key output format and side-effect note. There is no filler, repetition, or unnecessary detail.

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

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

For a code-generation tool, the description covers the target platform, return value, and non-persistence, while the schema covers all inputs. It does not explicitly state that the contract is not deployed or that no blockchain transaction occurs, but the 'Does not write to disk' line implies a local generation-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 has 100% description coverage, so the baseline is 3; the description itself adds no parameter-level semantics. The schema already documents all five parameters and their nested fields with useful descriptions, so the lack of parameter details in the description is acceptable.

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 ('Make a custom smart contract') and resource ('TRON Virtual Machine'), and the word 'custom' distinguishes it from standard TRON templates like tron-trc20 or tron-trc721. It is not a tautology and clearly indicates what the tool produces, though it could more explicitly describe the nature of the customization.

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

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

There is no explicit guidance on when to use this tool rather than the many sibling tools. The description relies on the word 'custom' to imply that it is for non-standard contracts, but it never names alternatives like tron-trc20, tron-trc721, or other chain-specific custom tools. An agent must infer the appropriate context.

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

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

With no annotations provided, the description carries the full behavioral burden. It explicitly discloses that the tool generates source code, returns it in a Markdown code block, and does not write to disk — key safety-relevant behavior. It does not disclose whether the generated contract is audited, whether it includes tests, or whether it may have chain-specific limitations, but the critical no-write behavior is clearly stated.

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

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

Two sentences with no filler. The key output/behavior detail (returns Markdown, does not write to disk) is front-loaded in the second sentence. It is appropriately concise for a tool with a rich schema.

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

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

Despite 17 parameters and nested objects, the schema is thorough and self-contained: defaults, conditional fields, and enum constraints are documented. The description covers the essential behavioral contract (code generation, return format, no disk write). Missing context includes what the generated code actually contains or whether cross-chain execution requires extra deployment steps, but the schema covers the key decision points and the output is source code, not a complex API 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 description coverage is 100%, so the baseline is 3. The description does not add parameter-level semantics beyond the schema, but the schema itself thoroughly documents each parameter with defaults and conditional relationships (e.g., decimals default differs by voting type, quorumPercent applies only when quorumMode equals percent). The description's high-level purpose helps the agent infer how parameters combine, but it doesn't add any extra meaning beyond the schema.

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

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

The description states a specific verb ('Make a contract to implement governance'), a specific resource ('for a DAO, targeting the TRON Virtual Machine'), and explicitly says it returns generated source code without writing to disk. This clearly distinguishes it from sibling tools like solidity-governor or cairo-governor by naming the TRON Virtual Machine target.

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 does not explicitly say when to use this tool versus alternatives. However, the tool name (tron-governor), the target 'TRON Virtual Machine', and sibling list of other chain-specific generators imply it is the choice for TRON governance contracts. No explicit exclusions or alternative routing are provided, leaving usage inference largely to the agent.

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 behavioral disclosure burden. It explicitly states that the tool returns source code in a Markdown code block and does not write to disk, which are the key behavioral traits an agent needs to know. It does not mention every possible side effect, but for a code-generation tool, these disclosures are substantial and useful.

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 and every sentence earns its place. The first sentence identifies what the tool generates and the target platform; the second conveys the return format and the non-destructive behavior. It is front-loaded and free of 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 12 parameters with full schema coverage and no output schema, the description appropriately clarifies the return format (Markdown code block) and the side-effect profile (does not write to disk). It does not enumerate generated contract features, but the standard name and schema descriptions cover the necessary details for invoking the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all 12 parameters. The description adds no additional parameter-level semantics, but it is not required to compensate because each parameter already has a thorough description in the schema. This meets the baseline for a fully documented 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 verb ('Make'), a clear resource ('multi-token contract per the TRC-1155 standard'), and a specific target ('TRON Virtual Machine'). This clearly distinguishes it from sibling tools like tron-trc20, tron-trc721, and solidity-erc1155. The additional note about returning source code and not writing to disk further clarifies what the tool actually does.

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

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

The description makes the intended use clear: use this tool when you need a TRC-1155 multi-token contract targeting TRON. It does not explicitly list alternatives or when-not-to-use conditions, but the standard and target are stated precisely enough that an agent can select it over related siblings like tron-trc20 or tron-trc721.

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 makes the side-effect-free behavior explicit ('Does not write to disk') and describes the return format ('formatted in a Markdown code block'), which are the key behavioral traits an agent needs before invoking.

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

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

Two sentences with no filler; the core action is first, and the critical non-side-effect and output-format traits follow. Every sentence earns its place.

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

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

The tool has 18 parameters and no output schema, but the description covers the essential invocation context: the standard, target VM, return shape, and absence of disk writes. It does not detail deployment behavior, but that is not implied by the tool's role as a code generator.

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

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

Schema coverage is 100%, and every parameter has a descriptive schema entry, so the description need not repeat parameter meaning. It adds no parameter guidance beyond the schema, which matches the baseline for full 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?

Description uses a specific verb-resource pair: 'Make a fungible token per the TRC-20 standard, targeting the TRON Virtual Machine.' This clearly separates it from solidity-erc20, cairo-erc20, and TRON non-fungible siblings.

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

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

The TRON Virtual Machine context makes it clear this is the tool for TRC-20 fungible tokens, and the output description indicates it is a code generator rather than a deployment tool. It doesn't explicitly compare against tron-custom or tron-trc721/1155, but the standard and target are unambiguous.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It clearly says the tool returns generated source code in a Markdown code block and does not write to disk, making the pure code-generation behavior explicit. It could also mention no deployment occurs, but the no-write statement substantially covers side-effect transparency.

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

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

Two short paragraphs with no filler: purpose first, then output format and side-effect caveat. Every sentence earns its place, and the key facts 'Returns source code' and 'Does not write to disk' are immediately available.

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 code-generation tool with a rich 16-parameter schema, the description covers purpose, output format, and side-effect boundary in two sentences. There is no output schema, but the description compensates by specifying the return format. It does not detail all possible behaviors, but the key invocation-relevant information is present.

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

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

Schema description coverage is 100%, so all parameters already have documented meanings in the schema. The description does not add parameter-level detail, but it clarifies that the output is a generated source code artifact rather than an actual chain deployment. Baseline 3 is appropriate.

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

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

States explicitly that the tool makes a non-fungible token per the TRC-721 standard on the TRON Virtual Machine. The verb 'Make' plus the resource 'non-fungible token per TRC-721' clearly distinguishes it from siblings such as tron-trc20 and tron-trc1155.

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 defines the use case by standard and target platform: it is the tool for TRC-721 non-fungible token contract generation on TRON. It does not explicitly name alternatives or state when not to use it, but the context is clear enough to route correctly among the TRON siblings.

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 to rely on, the description carries the full burden of behavioral disclosure. It explicitly states that the tool returns source code in a Markdown code block and does not write to disk, which transparently communicates the side-effect-free nature and output 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?

Two sentences with no filler: first sentence states the purpose, second sentence describes behavior and output. Every word earns its place, and the most important information is front-loaded.

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

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

Despite the tool's complexity (11 params, nested objects), the description covers the core action and return format, which is essential given no output schema exists. The schema itself provides deep parameter detail, making the combination adequate for a knowledgeable agent.

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

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

Schema description coverage is 100% and each parameter has detailed descriptions, so the schema already handles parameter semantics. The tool description itself adds no parameter-specific meaning, matching the baseline for comprehensive 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 uses a specific verb and resource ('Make a Uniswap v4 hook contract') and is distinct from sibling tools which generate other contract types (ERC20, ERC721, etc.). It clearly identifies the tool's focus and 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?

No guidance is provided on when to use this tool versus alternatives. The description states what the tool does but does not mention any exclusions, prerequisites, or context in which a different contract generator would be more appropriate.

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