Stacks Clarity MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, but there is some overlap in generation and analysis tools. For example, generate_clarity_contract and generate_sip009_template both create contracts, though one is generic and the other specific. Similarly, analyze_contract_performance and generate_optimization_recommendations both focus on optimization, which could cause confusion. However, descriptions help differentiate them, and most tools target unique resources or actions.
Naming Consistency5/5
Tool names follow a highly consistent verb_noun pattern throughout, such as analyze_contract_performance, check_stx_balance, and generate_sip009_template. There are no deviations in naming conventions, with all tools using snake_case and clear, descriptive verbs. This predictability makes it easy for agents to understand and select tools.
Tool Count2/5
With 36 tools, the count is excessive for the server's purpose of Stacks Clarity development and management. Many tools could be consolidated or removed without losing functionality, such as multiple generate_* tools or prompt tools. This large number may overwhelm agents and lead to inefficiency, indicating a poor scope management.
Completeness5/5
The tool set provides comprehensive coverage for Stacks Clarity development, including contract analysis, generation, testing, token standards (SIP-009/010), transaction handling, balance checks, and debugging. There are no obvious gaps; it supports full CRUD/lifecycle operations for contracts and tokens, along with essential utilities like address validation and version checking.
Average 3.3/5 across 36 of 36 tools scored. Lowest: 2.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
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 mentions 'security best practices' but does not detail what these entail, such as validation steps, error handling, or output format. The description lacks information on permissions, side effects, or performance characteristics, which is inadequate for a tool that likely involves complex template generation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core function without unnecessary details. It is front-loaded and avoids redundancy, though it could be slightly more informative without losing conciseness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of generating templates with security best practices, no annotations, and no output schema, the description is insufficient. It does not explain what the output looks like, how templates are structured, or what 'complete' entails, leaving significant gaps for the agent to infer behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting both parameters (transactionType and assets). The description does not add any additional meaning beyond the schema, such as explaining how assets are used in templates or what 'common patterns' map to transactionType values. Thus, it meets the baseline of 3 without compensating for gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool generates a 'complete post-condition template for common transaction patterns with security best practices', which provides a general purpose. However, it lacks specificity about what constitutes 'complete' or 'common patterns', and does not differentiate from sibling tools like generate_fungible_post_condition or generate_non_fungible_post_condition, making it somewhat vague.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description offers no guidance on when to use this tool versus alternatives, such as the more specific post-condition generation siblings. It implies usage for transaction patterns but does not specify contexts, prerequisites, or exclusions, leaving the agent without clear direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool 'analyzes' and 'provides' outputs, which implies a read-only operation, but doesn't specify whether it requires specific permissions, has rate limits, whether the analysis is cached, what format the output takes, or any side effects. For a tool with 3 parameters and no annotation coverage, this is insufficient 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences that cover purpose and outputs. It's appropriately sized for the tool's complexity, though it could be slightly more front-loaded by mentioning the key parameters. Every sentence contributes meaningful information without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given moderate complexity (3 parameters, no output schema, no annotations), the description provides basic purpose and outputs but lacks important context. It doesn't explain the relationship to sibling tools, doesn't describe output format or structure, and provides minimal behavioral guidance. For a tool that performs analysis and provides recommendations, more completeness about what 'detailed cost breakdown' entails would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain what 'SIP-012 optimization opportunities' means in practice, how 'optimizationLevel' affects the analysis, or provide examples of contractCode format. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool analyzes Clarity contracts for performance bottlenecks and SIP-012 optimization opportunities, providing cost breakdowns and recommendations. It specifies the resource (Clarity contract) and outcomes (bottlenecks, optimization, cost breakdown). However, it doesn't explicitly differentiate from sibling tools like 'generate_optimization_recommendations' or 'estimate_operation_cost' that might overlap in functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'generate_optimization_recommendations' and 'estimate_operation_cost' that might serve similar purposes, there's no indication of when this specific analysis tool is preferred, what prerequisites exist, or when other tools might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool configures settings, adds dependencies, and sets up environments—implying mutation operations—but doesn't disclose critical behaviors like whether changes are reversible, permission requirements, side effects on existing configurations, or error handling. For a configuration tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Configure Clarinet project settings') and lists key actions. There's no wasted text, and it's appropriately sized for the tool's scope. However, it could be slightly more structured (e.g., separating network configuration from dependency management) to enhance clarity, preventing a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (configuration with potential side effects), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like what 'configure' entails (e.g., file modifications, environment variables), how dependencies are added, or what the setup outcome looks like. For a mutation tool without structured safety or output information, the description should provide more context to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 both parameters ('network' with enum values and 'requirements' as an array). The description adds no additional meaning beyond what the schema provides—it mentions 'different networks' and 'dependencies' but doesn't clarify parameter usage, constraints, or examples. With high schema coverage, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('configure', 'add', 'set up') and resources ('Clarinet project settings', 'dependencies', 'development environment'). It distinguishes from siblings like 'generate_clarinet_project' (which creates rather than configures) and 'build_clarity_smart_contract' (which builds rather than configures). However, it doesn't explicitly differentiate from all siblings, keeping it at a 4 rather than a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., after generating a project), exclusions, or comparisons to siblings like 'generate_clarinet_project' (for initial setup) or environment-specific tools. Without any usage context, the agent must infer when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions generating a 'complete setup' but doesn't specify whether this creates files on disk, requires write permissions, overwrites existing projects, or includes dependencies. For a tool that likely performs file system operations, this is a significant gap in transparency about its behavior and potential side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action ('Generate a complete Clarinet project setup') and specifies key aspects (structure, configuration, starter contracts). There's no wasted verbiage, but it could be slightly more structured by separating setup components or adding brief context.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of generating a project setup (likely involving file creation and configuration), the description is incomplete. No annotations cover safety or behavior, and there's no output schema to clarify what's returned (e.g., success status, project path). The description doesn't compensate for these gaps, leaving the agent with insufficient information to understand the tool's full impact and results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 three parameters (projectName, projectPath, template) with descriptions and enum values. The description adds no additional semantic context beyond implying that parameters relate to project generation. This meets the baseline for high schema coverage but doesn't enhance understanding of how parameters interact or affect the outcome.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a complete Clarinet project setup with proper structure, configuration, and starter contracts.' It specifies the verb ('Generate') and resource ('Clarinet project'), including key components like structure, configuration, and contracts. However, it doesn't explicitly differentiate from sibling tools like 'configure_clarinet_project' or 'build_clarity_smart_contract', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing Clarinet installed), compare to similar tools like 'configure_clarinet_project' (which might modify existing projects), or specify use cases (e.g., starting a new project from scratch). This lack of context leaves the agent guessing about appropriate usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'SIP compliance' and 'security best practices' but doesn't disclose critical behavioral traits such as whether this creates new files, overwrites existing ones, requires specific permissions, or has rate limits. For a generation tool with zero annotation coverage, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the main purpose. It avoids redundancy and wastes no words, though it could be slightly more structured by separating compliance from functionality aspects.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations, no output schema, and a generation tool with potential behavioral complexity, the description is incomplete. It lacks details on output format, error handling, or integration with other tools, leaving gaps for an AI agent to understand full context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 parameters (contractName, contractType, features). The description adds no additional meaning beyond what's in the schema, such as explaining SIP compliance implications or feature interactions. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool generates a 'complete Clarity contract' with specific compliance and functionality aspects (SIP compliance, security best practices, comprehensive functionality). It distinguishes from siblings like 'generate_sip009_template' or 'build_clarity_smart_contract' by emphasizing completeness and compliance, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives like 'generate_sip009_template' or 'build_clarity_smart_contract'. The description implies usage for generating compliant contracts but lacks context on prerequisites, exclusions, or comparisons to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. While it indicates the tool generates test suites, it doesn't specify whether this is a read-only operation, if it modifies files or systems, what permissions are required, or any rate limits. For a tool that likely involves file generation or system interaction, this omission is significant, as the agent lacks critical behavioral context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and to the point, making it easy to parse. However, it could be slightly improved by structuring it to highlight key aspects, but overall, it earns its place with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of generating test suites (which may involve file creation or system changes), the lack of annotations and output schema means the description should provide more behavioral and output context. It adequately covers the basic purpose but fails to address critical aspects like what the tool returns, error handling, or dependencies. For a tool with no structured safety or output information, this is a moderate gap, making it just above minimal viability.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, clearly documenting all parameters: 'contractName', 'scenarios', and 'testType' with an enum. The description adds no additional semantic details beyond what the schema provides, such as examples or constraints. According to the rules, with high schema coverage, the baseline is 3, as the schema adequately handles parameter documentation without needing extra description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate comprehensive test suites for Clarity contracts including unit tests, integration tests, and security tests.' It specifies the verb ('generate'), resource ('test suites for Clarity contracts'), and scope ('unit tests, integration tests, and security tests'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'analyze_contract_performance' or 'validate_stacks_address', which might involve testing-related activities, so it falls short of a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, such as needing an existing contract or project setup, nor does it suggest when to choose this over other testing or analysis tools in the sibling list. This lack of contextual usage information leaves the agent to infer appropriate scenarios without explicit direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool 'generates' recommendations, implying a read-only or advisory operation, but doesn't clarify if it modifies contracts, requires authentication, has rate limits, or produces structured vs. textual output. For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary details. Every word earns its place by specifying the action, target, and context concisely, making it easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of contract optimization, lack of annotations, and no output schema, the description is insufficient. It doesn't explain what the recommendations entail (e.g., code snippets, configuration changes), how they're formatted, or any dependencies on other tools. For a generative tool with three parameters and no structured output, more context is needed for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all parameters well-documented in the schema itself (e.g., 'contractPattern' with enum values, 'currentIssues' as an array of strings, 'targetThroughput' as a string). The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate specific optimization recommendations for Clarity contracts based on SIP-012 improvements and best practices.' It specifies the verb ('generate'), resource ('optimization recommendations'), and domain context ('Clarity contracts', 'SIP-012 improvements', 'best practices'). However, it doesn't explicitly differentiate from sibling tools like 'analyze_contract_performance' or 'stacks_clarity_best_practices_prompt', which might have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions 'SIP-012 improvements and best practices' as a basis, but doesn't specify scenarios, prerequisites, or exclusions. With many sibling tools in the Clarity/Stacks ecosystem (e.g., 'analyze_contract_performance', 'generate_clarity_contract'), the lack of comparative context leaves usage ambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While it implies a read-only operation ('Get information'), it doesn't specify whether this requires authentication, has rate limits, returns paginated results, or what happens with invalid inputs. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. It wastes no words but could be slightly more structured by separating purpose from returned data points. Every word earns its place, making it appropriately concise for a simple retrieval tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters with full schema coverage but no annotations and no output schema, the description is minimally adequate. It states what information is returned (total supply, last token ID), which partially compensates for the missing output schema. However, for a tool with no behavioral annotations, it should ideally disclose more about operational constraints or error conditions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 three parameters (contractAddress, contractName, network) with descriptions and enum values. The description doesn't add any parameter-specific context beyond what's in the schema, such as format examples or interdependencies. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get information about a SIP-009 NFT collection including total supply and last token ID.' It specifies the verb ('Get'), resource ('SIP-009 NFT collection'), and key data points returned. However, it doesn't explicitly differentiate from sibling tools like 'get_sip009_token_info' (which gets info about individual tokens rather than collections).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_sip009_token_info' for token-level details or 'get_sip010_info' for fungible tokens, nor does it specify prerequisites or contextual constraints for collection information retrieval.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions the tool is for security analysis but doesn't describe what the analysis entails, what output to expect, whether it's read-only or has side effects, or any performance or rate limit considerations. This leaves significant gaps for an AI agent to understand how to use it effectively.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences that are front-loaded: the first states the core purpose, and the second adds context. There's no wasted text, but it could be slightly more structured by explicitly mentioning the input parameters or output expectations.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of analyzing contract calls for security post-conditions, no annotations, and no output schema, the description is insufficient. It doesn't explain what the analysis returns, how to interpret results, or any behavioral traits. For a tool with 4 required parameters and security implications, more context is needed to be complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so the schema already documents all parameters well. The description doesn't add any additional meaning or context about the parameters beyond what's in the schema. According to the rules, with high schema coverage, the baseline is 3 even without param info in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Analyze a contract call to determine what post-conditions are required for security.' It specifies the action (analyze), resource (contract call), and outcome (determine post-conditions). However, it doesn't explicitly differentiate from sibling tools like 'generate_post_condition_template' or 'generate_fungible_post_condition', which appear related to post-conditions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage context with 'Essential for complex transactions,' implying it should be used for complex rather than simple transactions. However, it doesn't offer explicit guidance on when to use this tool versus alternatives like 'generate_post_condition_template' or other post-condition tools, nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'production-ready' and 'security features' but doesn't disclose critical behavioral traits like whether this generates source code, configuration files, or deployment scripts; what format the output takes; whether it requires specific permissions; or any rate limits. The description is too vague about what 'generate' actually entails operationally.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. While concise, it could be more structured by separating functional description from quality attributes. Every word earns its place, but it's slightly dense with multiple concepts ('complete, production-ready, security features, optional marketplace functionality') in one clause.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a code generation tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'generate' means in practice (creates files? returns code as text?), doesn't mention output format or structure, and provides no context about the generated template's characteristics beyond vague 'production-ready' and 'security features' claims.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 6 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain relationships between parameters (e.g., how includeMarketplace interacts with other features) or provide usage examples. Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('generate') and resources ('complete, production-ready SIP-009 NFT contract template'). It distinguishes from siblings by specifying SIP-009 (vs SIP-010 templates) and mentioning security features and optional marketplace functionality, which differentiates it from generic contract generation tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. While it mentions 'SIP-009 NFT contract template,' it doesn't specify when to choose this over other contract generation tools (like generate_sip010_template) or when to use it versus building contracts manually. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions 'proper post-conditions' and 'returns the transaction parameters for wallet signing,' which gives some context about output and safety (non-destructive generation). However, it lacks details on error conditions, rate limits, authentication needs, or what constitutes 'proper' post-conditions. For a transaction generation tool with zero annotation coverage, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and well-structured in two sentences: the first states the purpose and key constraint, and the second specifies the return value. Every word earns its place, with no redundancy or fluff, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (transaction generation with 7 parameters), no annotations, and no output schema, the description is minimally adequate but has gaps. It covers the basic purpose and output format but lacks behavioral details (e.g., error handling, side effects) and usage context. With 100% schema coverage, the parameter documentation is handled, but overall completeness is limited for a tool that generates financial transactions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no parameter-specific information beyond what's already in the input schema, which has 100% coverage with detailed descriptions for all 7 parameters. The baseline is 3 when schema coverage is high, as the schema adequately documents parameters like 'amount' (in base units), 'contractAddress' (format example), and 'network' (enum values). No additional semantic value is provided in the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a SIP-010 fungible token transfer transaction with proper post-conditions.' It specifies the verb ('generate'), resource ('SIP-010 fungible token transfer transaction'), and key constraint ('with proper post-conditions'). However, it doesn't explicitly differentiate from sibling tools like 'generate_sip009_transfer' or 'generate_fungible_post_condition', which would require a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'generate_sip009_transfer' for different token standards, 'generate_fungible_post_condition' for just post-conditions, or 'generate_stx_post_condition' for STX transfers. There's no context about prerequisites, such as needing token balances or network connectivity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states what data is retrieved but doesn't mention potential limitations like rate limits, authentication requirements, error conditions, or whether this is a read-only operation. For a tool with 4 required parameters and no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently communicates the core functionality. It's front-loaded with the main purpose and specifies exactly what information is retrieved without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read operation with 100% schema coverage but no output schema, the description adequately covers what data is retrieved. However, without annotations or output schema, it doesn't specify the return format, structure, or potential limitations. The description is complete enough for basic understanding but lacks depth for reliable agent usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 4 parameters thoroughly. The description doesn't add any parameter-specific details beyond what's in the schema descriptions. The baseline of 3 is appropriate when the schema does the heavy lifting for parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('SIP-009 NFT'), and specifies what information it retrieves (owner, metadata URI, metadata content). However, it doesn't explicitly differentiate from sibling tools like 'get_sip009_collection_info' or 'get_sip010_info', which handle different NFT standards or collection-level data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_sip009_collection_info' for collection-level info or 'get_sip010_info' for fungible tokens, nor does it specify prerequisites or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It describes the output content (token info attributes) but lacks behavioral details such as whether this is a read-only operation, potential rate limits, error conditions, or response format. For a tool with no annotations, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the purpose and lists key output attributes without unnecessary details. Every word earns its place, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description covers the purpose and output attributes adequately but lacks behavioral context (e.g., read-only nature, error handling) and doesn't explain return values beyond listing attributes. For a tool with 3 parameters and no structured output, it's minimally viable but could be more complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all parameters well-documented in the schema (contractAddress, contractName, network with enum). The description adds no parameter-specific information beyond implying these are needed to fetch token info, so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and resource 'complete information about a SIP-010 fungible token' with specific attributes listed (name, symbol, decimals, total supply, metadata URI). It distinguishes from some siblings like 'get_sip010_balance' (balance vs. token info) but doesn't explicitly differentiate from 'get_sip009_token_info' or 'get_sip009_collection_info' which are similar for different token standards.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_sip010_balance' (for balance queries) or 'get_sip009_token_info' (for SIP-009 tokens). It states what it does but not when it's appropriate, leaving the agent to infer usage from context alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 mentions 'simple and fast' but doesn't cover critical aspects like rate limits, authentication needs, error handling, or what the output looks like (e.g., balance format, units). For a read operation tool, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized with two concise sentences that are front-loaded with the core purpose and followed by a usage note. Every sentence adds value without redundancy, making it efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete for a tool with two parameters. It lacks details on behavioral traits (e.g., performance, errors) and output format, which are crucial for an agent to use it effectively. The high schema coverage doesn't compensate for these gaps in context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters ('address' and 'token') thoroughly. The description adds no additional semantic details beyond what's in the schema, such as examples or constraints, resulting in the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('check') and resource ('STX balance for a Stacks address'), and distinguishes it from other balance tools like 'get_sip010_balance' by specifying STX. However, it doesn't explicitly differentiate from 'get_stacks_account_info' which might also provide balance information, keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context with 'simple and fast balance lookup,' suggesting it's for quick checks, but it doesn't explicitly state when to use this tool versus alternatives like 'get_stacks_account_info' or 'get_sip010_balance,' nor does it provide exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool is 'based on SIP-012 cost functions,' which adds some context about the estimation methodology, but it doesn't describe key behavioral traits such as whether this is a read-only operation, what the output format looks like (e.g., cost units, error handling), or any limitations (e.g., accuracy, supported operations beyond the enum). For a tool with no annotations, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with two sentences that directly state the purpose and usage context without unnecessary details. Every sentence earns its place by clarifying the tool's function and utility. However, it could be slightly more structured by explicitly separating purpose from guidelines, but it remains efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and hints at usage but lacks details on behavioral aspects like output format, error cases, or integration with sibling tools. Without annotations or an output schema, the description should do more to compensate, but it falls short of being fully complete for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with clear documentation for each parameter (e.g., 'dataSize' as 'Size of data being processed,' 'operation' with an enum list). The description doesn't add any additional semantic meaning beyond what's already in the schema, such as explaining how 'dataSize' and 'iterations' interact or providing examples of cost estimation outputs. Since the schema does the heavy lifting, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Estimate the computational cost of specific Clarity operations based on SIP-012 cost functions.' It specifies the verb ('estimate'), resource ('computational cost'), and domain ('Clarity operations'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'analyze_contract_performance' or 'generate_optimization_recommendations', which might have overlapping optimization-related purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance with 'Useful for planning contract optimization,' suggesting it should be used during optimization planning phases. However, it doesn't explicitly state when to use this tool versus alternatives (e.g., 'analyze_contract_performance' for post-execution analysis or 'generate_optimization_recommendations' for actionable advice), nor does it mention any exclusions or prerequisites for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It mentions 'proper post-conditions' but doesn't explain what these entail, their security implications, or whether the tool validates inputs. It also omits critical details like error handling, rate limits, or authentication requirements for a transaction-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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently communicates the core purpose and output. Every word serves a clear function, with no redundant or vague phrasing, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a transaction-generation tool with no annotations and no output schema, the description is insufficient. It lacks details on output format, error cases, security considerations, and how the generated transaction should be used post-signing. The absence of behavioral context makes it incomplete for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, providing detailed parameter documentation. The description adds no additional parameter semantics beyond implying the tool handles post-conditions, which is already suggested by the tool's purpose. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('generate a SIP-009 NFT transfer transaction'), the resource involved (SIP-009 NFT), and the output ('transaction parameters for wallet signing'). It distinguishes itself from sibling tools like 'generate_sip010_transfer' by specifying the SIP-009 standard.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing ownership verification), differentiate from similar tools like 'generate_non_fungible_post_condition', or specify use cases beyond the generic transfer scenario.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. While 'generate' implies a creation operation, it doesn't specify whether this requires authentication, what format the output takes (e.g., Clarity source code file), whether it's idempotent, or any rate limits. The mention of 'production-ready' and 'security features' hints at quality but lacks concrete behavioral details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place by specifying completeness, production-readiness, standard (SIP-010), token type (fungible), and quality aspects (security features, best practices).
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 5-parameter tool with no annotations and no output schema, the description is adequate but has clear gaps. It covers the 'what' well but lacks behavioral context (authentication, output format) and usage guidelines. The 100% schema coverage helps, but the description should do more given the tool's complexity and lack of structured behavioral hints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 5 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema descriptions (e.g., doesn't explain relationships between parameters like how initialSupply interacts with decimals). Baseline 3 is appropriate when schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('generate') and resource ('complete, production-ready SIP-010 fungible token contract template'), specifying it includes 'all security features and best practices'. This distinguishes it from sibling tools like generate_sip009_template or generate_clarity_contract by focusing specifically on SIP-010 fungible tokens with production readiness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this over generate_sip009_template (for NFTs) or generate_clarity_contract (for general contracts), nor does it specify prerequisites like needing a Stacks wallet or development environment setup.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool generates post-conditions but doesn't describe what that entails operationally—e.g., whether it's a read-only calculation, if it requires network access, potential errors, or output format. For a tool with no annotations, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with two clear sentences: the first states the purpose, and the second adds context. There's no wasted text, making it efficient. However, it could be slightly more structured by explicitly separating purpose from usage, preventing a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It covers the purpose and basic usage but lacks details on behavior, output, or integration with sibling tools. Without annotations or an output schema, more context would be helpful for an AI agent to use it effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already documents all three parameters thoroughly. The description adds no additional parameter information beyond what's in the schema, such as examples or edge cases. This meets the baseline score of 3, as the schema does the heavy lifting, but the description doesn't enhance understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate an STX post-condition for STX transfers.' It specifies the verb ('generate') and resource ('STX post-condition'), and adds context about use cases ('Essential for payment and fee transactions'). However, it doesn't explicitly differentiate from sibling tools like 'generate_fungible_post_condition' or 'generate_non_fungible_post_condition', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance by stating the tool is 'Essential for payment and fee transactions,' which suggests when to use it. However, it doesn't explicitly mention when not to use it or name alternatives among the many sibling tools, such as the other post-condition generators. This leaves some ambiguity about tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It describes what content is returned but doesn't mention important behavioral aspects like whether this is a read-only operation, if there are rate limits, how current the documentation is, or what format the documentation comes in. The description is minimal about operational characteristics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise - a single sentence that efficiently communicates the tool's purpose. Every word earns its place: 'Get' (action), 'complete Clarity Book' (resource), 'comprehensive Clarity language documentation' (content type), and 'covering all language features, syntax, and best practices' (scope). No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a parameterless documentation retrieval tool with no output schema, the description is adequate but could be more complete. It explains what content is returned but not the format (HTML, PDF, structured data?), size considerations, or how current the documentation is. For a tool that presumably returns substantial documentation, more operational context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%. The description appropriately doesn't discuss parameters since none exist. It focuses on what the tool returns rather than inputs, which is correct for a parameterless tool. The baseline for 0 parameters with high schema coverage is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get the complete Clarity Book' with specific details about what it contains ('comprehensive Clarity language documentation covering all language features, syntax, and best practices'). It uses a specific verb ('Get') and resource ('Clarity Book'), but doesn't explicitly differentiate from sibling tools like 'get_sip' or 'list_sips' which might also retrieve documentation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this comprehensive documentation retrieval is preferred over more specific tools like 'get_sip' for individual SIPs or 'search_sips' for targeted searches. There's no context about prerequisites or limitations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states the tool returns a version, implying a read-only operation, but doesn't specify whether this requires authentication, has rate limits, or what the return format looks like (e.g., string, object). For a tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose and efficiently conveys the essential information without unnecessary elaboration, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on return format or behavioral context. For such a simple tool, this might be sufficient, but it doesn't fully compensate for the absence of annotations or output schema, resulting in a middle score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema fully documents the lack of inputs. The description doesn't need to add parameter information, and it correctly implies no parameters are required, earning a baseline score of 4 for this dimension.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Returns') and resource ('the version of the MCP server'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools, which are all related to Stacks blockchain development rather than MCP server metadata, so it's naturally distinct but not explicitly contrasted.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention any prerequisites, context for usage, or compare it to other tools that might provide related information, leaving the agent to infer usage based on 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.
Behavior2/5
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 mentions 'pagination support' which is useful, but fails to describe critical traits like whether this is a read-only operation, potential rate limits, authentication requirements, error conditions, or the format/structure of returned data. For a tool with 3 parameters and no output schema, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and includes the key feature (pagination support). There's zero wasted language, and every word earns its place in conveying essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (3 parameters, no output schema, no annotations), the description is insufficiently complete. It doesn't explain what 'detailed transaction history' includes, the response format, error handling, or behavioral constraints. For a data retrieval tool with pagination, users need more context about what to expect from the output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all parameters well-documented in the schema itself (address, limit with default/max, offset). The description adds no additional parameter semantics beyond what's already in the schema, so it meets the baseline score of 3 for high schema coverage without adding extra value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get detailed transaction history') and resource ('for a Stacks address'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'get_stacks_account_info' or 'check_stx_balance' that might also provide transaction-related data, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning 'pagination support,' suggesting this tool is for retrieving multiple transactions. However, it provides no explicit guidance on when to use this versus alternatives like 'get_stacks_account_info' or 'analyze_transaction_post_conditions,' nor does it mention prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions searching 'all SIPs' and being 'useful for finding standards,' but lacks details on how results are returned (e.g., format, pagination, sorting), error handling, or any rate limits. For a search tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with two sentences that efficiently convey the tool's purpose and utility. There's no unnecessary information, and each sentence adds value. However, it could be slightly more structured by explicitly separating purpose from usage guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (a search function with one parameter) and no output schema or annotations, the description is adequate but incomplete. It covers the basic purpose and usage but lacks details on behavioral aspects like result format or error handling. For a search tool, this leaves room for improvement in providing a complete context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'query' parameter well-documented in the schema. The description adds minimal value beyond this, only reinforcing that it's for 'content matching a specific query' without providing additional syntax, examples, or constraints. Given the high schema coverage, 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search through all SIPs for content matching a specific query.' It specifies the verb ('Search'), resource ('all SIPs'), and scope ('content matching a specific query'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'list_sips' or 'get_sip', which could help avoid confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance: 'Useful for finding standards related to specific topics.' This suggests it's for topic-based searches, but it doesn't explicitly state when to use this tool versus alternatives (e.g., 'list_sips' for browsing all SIPs or 'get_sip' for retrieving a specific SIP by ID). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the tool 'Returns the balance in base units (consider decimals for display),' which adds useful context about output format. However, it lacks details on error conditions, rate limits, authentication needs, or whether this is a read-only operation (though implied by 'Get'). More behavioral traits would improve transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with zero waste. The first sentence states the purpose, and the second adds critical behavioral context about return format. It's front-loaded and appropriately sized for a simple query tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is moderately complete. It covers the core purpose and output format but lacks details on error handling, network-specific behaviors, or how to interpret the balance with decimals. For a 4-parameter tool with full schema coverage, this is adequate but leaves gaps in operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 four parameters thoroughly. The description adds no parameter-specific information beyond implying that 'address' is for balance checking and 'contractAddress/contractName' identify the token. This meets the baseline for high schema coverage but doesn't enhance understanding of parameter interactions or semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get the SIP-010 fungible token balance for a specific address.' It specifies the verb ('Get'), resource ('SIP-010 fungible token balance'), and target ('specific address'). However, it doesn't explicitly differentiate from sibling tools like 'check_stx_balance' or 'get_sip010_info', which reduces clarity about when to choose this specific tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'check_stx_balance' (for STX balances) or 'get_sip010_info' (for token metadata), nor does it specify prerequisites or exclusions. The agent must infer usage from the tool name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose whether this is a read-only operation, requires authentication, has rate limits, returns paginated results, or what format 'recent activity' includes. The description is functional but misses key operational context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose and enumerates key data points without unnecessary words. Every element serves a clear purpose in communicating the tool's scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 3 parameters, 100% schema coverage, and no output schema, the description is minimally adequate. It covers what data is retrieved but lacks context about behavioral traits, response format, or error conditions. Given the absence of annotations and output schema, more operational guidance would be beneficial.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds marginal value by mentioning 'tokens' and 'recent activity' which map to the optional boolean parameters, but doesn't provide additional semantic context beyond what the schema already specifies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Get') and resource ('Stacks account'), listing key information retrieved (STX balance, nonce, tokens, recent activity). It distinguishes from sibling tools like 'check_stx_balance' by offering comprehensive data, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when comprehensive account information is needed, but provides no explicit guidance on when to use this tool versus alternatives like 'check_stx_balance' or 'get_transaction_history'. No prerequisites, exclusions, or comparative context are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It describes when to use the tool but doesn't disclose what the tool actually does behaviorally - whether it generates a message, triggers a notification, modifies conversation state, or has any side effects. For a tool with zero annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that clearly states the tool's purpose and usage conditions. It's appropriately sized for what appears to be a simple reminder tool with no parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given this is a tool with no annotations, no output schema, and unclear behavioral characteristics, the description is incomplete. It explains when to use the tool but not what the tool actually does or what happens when invoked. For a tool that appears to be a system prompt or reminder mechanism, more context about its function and effects would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage. The description doesn't need to explain any parameters, and it correctly doesn't attempt to do so. This meets the baseline expectation for parameterless tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the purpose is to 'reinforce MCP consultation habits' when conversations go too long without tool use or when implementing new Stacks features. This is somewhat vague about what the tool actually does (it appears to be a reminder prompt rather than an action tool), and it doesn't clearly distinguish itself from sibling prompt tools like 'stacks_clarity_best_practices_prompt' or 'stacks_debugging_helper_prompt' beyond the specific triggering conditions mentioned.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use guidance: 'when you notice the conversation has gone few exchanges without using MCP tools, or when implementing new Stacks features.' This gives clear context for invocation, though it doesn't specify when NOT to use it or explicitly name alternatives among the sibling prompt tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It describes what the tool does (validation) but doesn't disclose important behavioral traits: whether this is a read-only operation (likely, but not stated), what happens with invalid addresses (returns error? boolean?), whether there are rate limits, or what the output format looks like. For a validation tool with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that communicates the core functionality without waste. It's appropriately sized for a straightforward validation tool and front-loads the essential information. Every word earns its place in this concise formulation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a relatively simple validation tool with 2 parameters and 100% schema coverage, the description is adequate but has gaps. Without annotations or output schema, it doesn't describe the return format (boolean? validation details? error messages?) or important behavioral aspects. The description covers the basic purpose but leaves the agent guessing about the tool's complete behavior and output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters clearly documented in the schema. The description adds minimal value beyond the schema by mentioning 'Stacks address' (implied by the tool name) and 'specified network' (already clear from the schema's enum). It doesn't provide additional context about address formats, network differences, or validation rules. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Validate a Stacks address format and check if it's correctly formatted for the specified network.' It specifies the verb (validate), resource (Stacks address), and scope (format correctness and network-specific validation). However, it doesn't explicitly differentiate from sibling tools like 'get_stacks_account_info' or 'check_stx_balance' which might also involve address validation as part of their functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context by mentioning 'for the specified network,' suggesting this tool should be used when network-specific address validation is needed. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_stacks_account_info' (which might validate addresses as part of account lookup) or when NOT to use it (e.g., for balance checks). The guidance is present but not comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 states that post-conditions are 'MANDATORY' which is useful context, but doesn't describe what the tool actually produces (e.g., a structured object, a string, a transaction component), whether it validates inputs, what happens on failure, or any side effects. For a tool with 6 required parameters and no output schema, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise - just two sentences that directly state the purpose and usage context. Every word earns its place with zero waste. The structure is front-loaded with the core purpose followed by important context about mandatory usage.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (6 required parameters, no output schema, no annotations), the description provides minimal but essential context about purpose and mandatory usage. However, it doesn't explain what the tool outputs, how to use the generated post-condition, or provide examples. For a tool that generates a critical transaction component, more context would be helpful despite the good schema coverage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 6 parameters with clear descriptions. The description doesn't add any additional parameter semantics beyond what's in the schema. The baseline score of 3 reflects adequate coverage through the schema alone, with no extra value from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a fungible token post-condition for SIP-010 tokens.' It specifies the verb ('generate'), resource ('fungible token post-condition'), and domain context ('SIP-010 tokens'). However, it doesn't explicitly differentiate from sibling tools like 'generate_non_fungible_post_condition' or 'generate_stx_post_condition' beyond the 'fungible' qualifier.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: 'Post-conditions are MANDATORY for all token transfers.' This indicates when to use the tool (for token transfers) and implies it's required rather than optional. However, it doesn't explicitly state when NOT to use it or name specific alternatives among sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'complete content' and 'including any Clarity smart contract code', which adds some behavioral context about what's returned. However, it doesn't disclose critical details like response format, error handling, rate limits, or authentication needs, leaving significant gaps for a tool with no annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place, with no redundant or vague phrasing, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 1 parameter with full schema coverage and no output schema, the description adequately covers the basic purpose. However, as a read operation with no annotations, it lacks details on return format, error cases, or behavioral constraints, making it minimally complete but with clear gaps for practical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'sipNumber' well-documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get the complete content'), resource ('a specific SIP'), and scope ('including any Clarity smart contract code'). It distinguishes from siblings like 'list_sips' (which lists) and 'search_sips' (which searches), making the purpose unambiguous and well-differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you need full SIP content by number, but doesn't explicitly state when to use this vs. alternatives like 'list_sips' or 'search_sips'. No exclusions or prerequisites are mentioned, leaving some ambiguity about optimal use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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. The description mentions it 'returns comprehensive resources' but doesn't specify what form these resources take (e.g., documentation links, code snippets, structured data), whether there are rate limits, authentication requirements, or any side effects. For a tool with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured in two sentences: the first states the purpose and outputs, the second provides usage guidance. Every word serves a clear function with no redundancy or fluff, making it easy to parse and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description adequately covers the basic purpose and usage. However, it lacks details on what the 'comprehensive resources' include (e.g., format, examples) and behavioral aspects like error handling or dependencies. For a guidance tool with many sibling alternatives, more context could help distinguish it better.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage. The description doesn't need to explain parameters, and it appropriately doesn't mention any. Since there are no parameters to document, the baseline score is 4, as the description correctly focuses on the tool's purpose rather than nonexistent inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Build a Clarity smart contract - returns comprehensive resources for Clarity development including SIP standards, security patterns, and best practices.' It specifies the verb ('Build') and resource ('Clarity smart contract') with concrete outputs. However, it doesn't explicitly differentiate from siblings like 'generate_clarity_contract' or 'generate_sip009_template', which appear to be more specific generation tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool: 'Use this tool when you need guidance on building smart contracts for Stacks.' This gives a specific scenario (guidance on building) and domain (Stacks). However, it doesn't mention when NOT to use it or explicitly name alternatives among the many sibling tools, which could help avoid confusion with similar-sounding tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool 'returns comprehensive resources' but doesn't disclose behavioral traits like whether this is a generative/creation tool vs. informational, what format/resources are returned, whether it requires specific inputs or permissions, or any limitations. For a zero-parameter tool with no annotations, this leaves significant behavioral questions unanswered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each earn their place. The first sentence states the purpose and scope, the second provides usage guidance. No wasted words, well-structured, and front-loaded with the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description adequately covers the tool's purpose and usage context. However, for a tool that 'returns comprehensive resources' with no annotations, it should ideally specify what kind of resources/format to expect. The description is complete enough for basic understanding but lacks details about the return value that would be helpful for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage. The description doesn't need to explain parameters, and it appropriately doesn't mention any. The baseline for zero parameters is 4, as there's no parameter information to add beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Build a complete full-stack Stacks dApp' with specific resources mentioned (Clarity contracts, frontend integration, token standards, security patterns). It distinguishes from siblings like 'build_clarity_smart_contract' and 'build_stacks_frontend' by covering the full stack, but doesn't explicitly contrast with other comprehensive tools like 'generate_clarinet_project'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'Use this tool when you need guidance on building complete Stacks applications.' This clearly indicates when to use it (for comprehensive dApp building guidance). However, it doesn't specify when NOT to use it or mention specific alternatives among the many sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states the tool 'returns comprehensive resources for frontend development' but doesn't specify what format these resources take (e.g., documentation links, code snippets, tutorials), whether there are rate limits, authentication requirements, or any behavioral constraints. For a tool with zero parameters, more detail about the return behavior would be expected.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise with two sentences that each serve distinct purposes: the first explains what the tool does, the second explains when to use it. No wasted words, and the most important information (the purpose) comes first.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description provides adequate basic information about purpose and usage. However, for a tool that 'returns comprehensive resources,' more detail about what those resources entail would help the agent understand what to expect. The lack of annotations means the description should compensate more for behavioral transparency.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0 parameters and 100% schema description coverage, the baseline is 4. The description appropriately doesn't discuss parameters since none exist, which is correct for this tool structure.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Build a Stacks dApp frontend' with specific resources mentioned (wallet integration, transaction signing, post-condition handling). It distinguishes from sibling tools like 'build_stacks_dapp' by focusing specifically on frontend development rather than full dApp development. However, it doesn't explicitly contrast with other frontend-related tools if they existed.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance: 'Use this tool when you need guidance on building frontends for Stacks dApps.' This clearly indicates the intended context. It doesn't mention specific alternatives or exclusions, but the context is well-defined for a zero-parameter tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the tool lists 'all available SIPs' and suggests using it for discovery, but doesn't disclose behavioral traits like whether it returns a complete list, pagination behavior, rate limits, or authentication needs. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose followed by usage guidance. Every sentence earns its place: the first defines what the tool does, and the second explains when to use it. There's zero waste or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema), the description is adequate but could be more complete. It covers purpose and basic usage, but without annotations or output schema, it doesn't describe what the return value looks like (e.g., format, structure) or other behavioral aspects. For a list operation, this is minimally viable but leaves room for improvement.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%. The description doesn't need to add parameter information beyond what the schema provides (no parameters). It appropriately focuses on the tool's purpose and usage without unnecessary parameter details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get a list of all available SIPs (Stacks Improvement Proposals) in the knowledge base.' It specifies the verb ('Get a list') and resource ('SIPs'), though it doesn't explicitly differentiate from sibling 'search_sips' beyond the 'all available' scope. The description avoids tautology by explaining what SIPs are.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: 'Use this first to discover available Stacks standards.' This gives a specific use case (initial discovery) but doesn't explicitly state when not to use it or mention alternatives like 'search_sips' for filtered searches. The guidance is helpful but could be more comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool 'Redirects to MCP-first debugging approach,' implying it might trigger a process or provide guidance, but it does not clarify what this entails—such as whether it modifies state, requires authentication, has rate limits, or what output to expect. This leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with key information in a single, efficient sentence. It wastes no words, clearly stating the tool's trigger conditions and action, making it easy to scan and understand quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (0 parameters, no output schema, no annotations), the description is minimally complete. It explains the purpose and usage context but lacks details on behavioral traits like what the 'MCP-first debugging approach' involves or expected outcomes. This is adequate for a simple prompt tool but could be more informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description does not mention parameters, which is appropriate. A baseline of 4 is applied as it adequately handles the lack of parameters without introducing confusion.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as an 'ERROR RECOVERY PROMPT' for 'Stacks/Clarity errors, stuck in debugging loops, or when about to try generic blockchain solutions,' with a specific action to 'Redirects to MCP-first debugging approach.' It distinguishes itself from siblings by focusing on error recovery rather than analysis, building, or querying, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit context for when to use the tool ('immediately when encountering Stacks/Clarity errors, stuck in debugging loops, or when about to try generic blockchain solutions'), which helps differentiate it from siblings like 'analyze_contract_performance' or 'build_clarity_smart_contract.' However, it does not specify when not to use it or name exact alternatives, leaving some ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
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 describes what content is returned but lacks behavioral details such as whether this is a read-only operation (implied by 'Get'), if there are rate limits, authentication requirements, or how the guidance is structured (e.g., examples, best practices). The description is functional but minimal on 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the tool's purpose and output without unnecessary words. It is front-loaded with the core action ('Get the essential token standards') and adds specific details (SIP types, Clarity traits, guidance) that earn their place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 0 parameters, no annotations, and no output schema, the description provides basic completeness by stating what it returns. However, it lacks details on output format (e.g., structured data, text), behavioral traits, or error handling, which could be important for an AI agent to use it effectively in context with sibling tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description does not discuss parameters, which is appropriate. A baseline of 4 is applied since it compensates adequately for the lack of parameters by focusing on output content.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('Get') and resources ('essential token standards for Stacks - SIP-009 (NFT) and SIP-010 (Fungible Token)'), including what content it provides ('Clarity trait definitions and implementation guidance'). It distinguishes itself from sibling tools like get_sip009_token_info or get_sip010_info by focusing on standards documentation rather than specific token data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when needing token standards information ('essential token standards... with... guidance'), but does not explicitly state when to use this tool versus alternatives like get_sip (which might retrieve SIP documents) or generate_sip009_template (for creating contracts). No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the tool as a 'PRIMARY PROMPT' that 'Sets up mandatory MCP consultation workflow' and 'ensures SIP compliance,' which implies it's a configuration or setup tool with specific compliance requirements. However, it lacks details on what the prompt contains, how it's applied, potential side effects, or any rate limits. The description adds some context but doesn't fully compensate for the absence of annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and front-loaded, consisting of a single sentence that efficiently conveys the tool's role, context, and key features ('mandatory MCP consultation workflow' and 'SIP compliance'). Every word serves a purpose, with no wasted text or unnecessary elaboration, making it easy to understand at a glance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity as a prompt for development workflows, the description is somewhat complete but has gaps. It explains the purpose and high-level goals but lacks details on what the prompt outputs, how it integrates with MCP, or what SIP compliance entails. With no output schema and no annotations, the description doesn't fully compensate for these missing structured fields, leaving room for ambiguity in practical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and the schema description coverage is 100%, so there's no need for parameter details in the description. The description appropriately focuses on the tool's purpose and usage without redundant parameter information. A baseline score of 4 is applied for zero-parameter tools, as the description doesn't need to explain parameters beyond what the schema already covers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Use this as the main system prompt when building any Stacks dApp or Clarity contract.' It specifies the verb ('use as main system prompt') and resource ('Stacks dApp or Clarity contract'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'stacks_clarity_development_reminder_prompt' or 'stacks_debugging_helper_prompt', which also appear to be prompt-related tools for Stacks development.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: 'when building any Stacks dApp or Clarity contract.' It also mentions specific goals ('Sets up mandatory MCP consultation workflow' and 'ensures SIP compliance'), which help guide usage. However, it doesn't explicitly state when not to use it or name alternatives among the sibling tools, such as when a simpler reminder or debugging prompt might suffice instead.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
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 states that post-conditions are 'MANDATORY,' which implies this is a required step for compliance or security in NFT transfers. However, it doesn't describe what the tool outputs, error conditions, or any side effects, leaving gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—two sentences that are front-loaded with the core purpose and usage rule. Every word earns its place, with no redundancy or unnecessary elaboration, making it efficient for an agent to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (6 required parameters for a specialized blockchain operation) and no output schema, the description is reasonably complete. It clarifies the tool's role in NFT transfers and the mandatory nature of post-conditions, but it could improve by hinting at the output format or linking to related tools like 'generate_sip009_transfer' for broader context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
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 6 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, such as explaining relationships between parameters (e.g., how assetName relates to contractName) or usage examples. This meets the baseline of 3 when schema coverage is high.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Generate a non-fungible token post-condition for SIP-009 NFTs.' It specifies the exact resource (SIP-009 NFT post-conditions) and distinguishes it from sibling tools like 'generate_fungible_post_condition' and 'generate_stx_post_condition' by focusing on NFTs rather than fungible tokens or STX.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'Post-conditions are MANDATORY for all NFT transfers.' This tells the agent when to use this tool (for NFT transfers) and implies it should not be used for other types of transactions, offering clear context without naming alternatives directly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![stacks-clarity-mcp MCP server](https://glama.ai/mcp/servers/exponentlabshq/stacks-clarity-mcp/badges/card.svg)](https://glama.ai/mcp/servers/exponentlabshq/stacks-clarity-mcp)

Score Badge

Copy to your README.md:

[![stacks-clarity-mcp MCP server](https://glama.ai/mcp/servers/exponentlabshq/stacks-clarity-mcp/badges/score.svg)](https://glama.ai/mcp/servers/exponentlabshq/stacks-clarity-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/exponentlabshq/stacks-clarity-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server