OpenZeppelin Cairo Contracts

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 present, the description carries the full behavioral burden. It clearly states that the tool returns generated source code in a Markdown code block and does not write to disk, which is key operational context for a code-generation tool. It does not explicitly mention whether it deploys or makes network calls, but 'returns the source code' reasonably implies no on-chain execution.

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. The primary action is front-loaded, followed by the return format and the important side-effect disclosure. 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 tool with 13 parameters, no output schema, and no annotations, the description provides essential operational context: generated source code returned as Markdown and no disk writes. It could mention the Cairo language explicitly or note that all the boolean flags configure generation, but the schema covers the flags and the title/name convey Cairo, so the core context is adequately covered.

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 input schema already documents the parameters in detail. The description adds no parameter-level semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific action and resource: 'Make a non-fungible token per the ERC-1155 standard.' It also names the standard explicitly, which helps distinguish it from sibling generators like cairo-erc20 or cairo-erc721. However, ERC-1155 is a multi-token standard, so describing it only as a 'non-fungible token' is somewhat reductive and could blur the boundary with cairo-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 guidance is given about when to use this tool instead of its siblings. The description does not mention ERC-1155's batch/multi-token use cases or contrast it with cairo-erc721 or cairo-erc20, leaving the agent to infer selection criteria from the standard 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?

no annotations are provided, so the description fully carries the behavioral disclosure. It clearly says the return value is source code in a Markdown code block and that the tool does not write to disk, which directly addresses side effects 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 wasted words. The core purpose is front-loaded, followed immediately by the output behavior. This structure makes the tool easy to scan and understand.

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 generator with 15 parameters and no output schema, the description covers the essentials: what is generated, in what format, and that nothing is written to disk. The schema supplies parameter details, defaults, and conditional constraints, so the definition is complete 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 description coverage is 93%, so the input schema already documents the parameters in detail. The description adds no additional parameter-level information, which is appropriate given the high schema coverage; baseline 3 applies.

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

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

States a specific verb ('Make'), a clear resource ('fungible token per the ERC-20 standard'), and differentiates from siblings like cairo-erc721 and cairo-erc1155. The return behavior is also specified, removing ambiguity about what the tool produces.

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

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

The description implies use for ERC-20 token generation but never explicitly names alternatives or states when not to use this tool. The sibling tool names suggest other standards, but no routing guidance is provided.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It discloses key behaviors: returns source code, formats it in a Markdown code block, and does not write to disk. It does not cover every failure mode or validation detail, but the most important side-effect behavior is addressed.

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 first states purpose, the second states output format and side-effect behavior. Every sentence earns its place and the essential 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?

Given a complex 11-param schema with nested objects and no output schema, the description covers the essential output format and the no-disk side effect. It does not elaborate on how options map to generated code, but high schema coverage compensates. Sibling differentiation is the main contextual gap.

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

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

Schema description coverage is 91%, so the schema already documents nearly all 11 properties. The description adds 'minimal' as a generation style but not parameter-level semantics. Baseline 3 is appropriate given the high schema coverage.

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

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

States a clear action: 'Make a minimal multi-token per the ERC-6909 standard.' The standard name differentiates it from sibling generators like cairo-erc721 or cairo-erc1155, though it doesn't spell out that differentiation. An agent can tell what artifact is produced.

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 naming ERC-6909 and 'minimal multi-token', but it does not explicitly state when to prefer it over cairo-erc1155 or cairo-erc20. No exclusions or alternative routing are provided. This is implied guidance, not explicit guidance.

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

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

With no annotations provided, the description carries the burden of behavior disclosure. It discloses two key behaviors: the result is source code in a Markdown code block, and the tool 'does not write to disk.' This gives an agent a clear, non-destructive mental model of the side effects, though it does not discuss rate limits, network calls, or other indirect side effects.

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

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

The description is two short sentences with no fluff. The core purpose is front-loaded, and the output format/side-effect statement is placed immediately after. Every sentence adds value.

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

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

This is a large, complex tool with 18 parameters and nested objects, but the schema covers those details well. The description fills the main gap left by the absent output schema by stating that a Markdown-formatted source code block is returned and nothing is written to disk. It is complete for a source-generation tool, though it could have added one sentence about the generated contract being intended for deployment.

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 input schema already documents the parameters thoroughly; the description need not repeat them. The description adds no new parameter meaning beyond the schema, which matches the baseline 3 for high schema coverage.

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

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

Description states a precise action: 'Make a non-fungible token per the ERC-721 standard.' This identifies both the resource type and the standard, which clearly distinguishes it from sibling tools like cairo-erc20 and cairo-erc1155. It also states the return format, so the purpose is fully transparent.

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

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

The intended use 'when an ERC-721 NFT contract is needed' is implied by the description, but no explicit alternatives or exclusions are given. An agent can infer the choice vs. ERC-20 or ERC-1155 from the token standard, but the description does not state when not to use this tool.

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

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

With no annotations provided, the description carries the 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.