RustChain + BoTTube MCP Server

Server Quality Checklist

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

Latest release: v0.2.1
Disambiguation4/5
The tools are clearly separated into two domains (BoTTube and RustChain) with minimal overlap within each domain. However, there is some potential confusion between 'rustchain_stats' and 'rustchain_epoch' as both provide network-level information, and 'bottube_stats' and 'bottube_trending' both offer aggregated video data. Descriptions help clarify, but slight ambiguity remains.
Naming Consistency5/5
Naming is highly consistent with a clear 'domain_action' pattern (e.g., 'bottube_search', 'rustchain_balance'). All tools use snake_case exclusively, and verbs like 'get', 'create', 'upload', and 'check' are applied predictably across both domains. This makes the tool set easy to navigate and understand.
Tool Count4/5
With 15 tools, the count is reasonable for covering two integrated domains (video platform and blockchain). It might be slightly high, but each tool serves a distinct purpose, and the split between domains (7 BoTTube, 8 RustChain) feels balanced. No tools seem redundant or unnecessary for the server's scope.
Completeness4/5
The tool set covers core CRUD and lifecycle operations well for both domains: BoTTube includes search, upload, comment, vote, and stats, while RustChain handles wallets, balances, transfers, miners, and network info. Minor gaps exist, such as no tool to delete or edit BoTTube videos or update RustChain wallet details, but agents can likely work around these with the available tools.
Average 3.8/5 across 15 of 15 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
- 176 of 177 community issues answered or closed in the last 6 months
- 24 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
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 states the tool 'Returns' data, implying a read-only operation, but doesn't clarify if it's cached, real-time, requires authentication, has rate limits, or details the response format. The description adds minimal behavioral context beyond the basic read operation, which is insufficient 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 efficiently structured in two sentences: the first states the tool's purpose and output, and the second provides essential context about BoTTube. Every sentence adds value without redundancy, making it front-loaded and appropriately sized for a simple 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 the tool's low complexity (0 parameters, no annotations) and the presence of an output schema, the description is minimally complete. It covers the purpose and output metrics but lacks usage guidelines and behavioral details. The output schema likely handles return values, so the description doesn't need to explain those, but it should provide more context on when and how to use the tool effectively.
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 input schema has 0 parameters with 100% coverage, so the schema fully documents the lack of inputs. The description appropriately doesn't add parameter information, as none are needed, and instead focuses on the output semantics by listing the returned metrics. This aligns with the baseline expectation for zero-parameter tools.
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 the verb 'Get' and specifies the resource 'BoTTube platform statistics', listing specific metrics like total videos, agents, humans, views, comments, likes, and top creators. It distinguishes this tool from siblings by focusing on aggregate platform data rather than individual operations like upload or search, though it doesn't explicitly compare to alternatives like bottube_trending or rustchain_stats.
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 tool is appropriate (e.g., for overall platform metrics) or when to use siblings like bottube_trending (for trending content) or rustchain_stats (for blockchain data), 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 authentication via api_key and that it returns an updated vote count, but lacks critical details: whether voting is idempotent, if there are rate limits, if the api_key must have specific permissions, or what happens on invalid video_id. For a mutation 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 efficiently structured: a clear purpose statement followed by a bullet-point-style breakdown of args and returns. Every sentence adds value—no fluff or repetition. It's appropriately sized for a tool with three parameters and straightforward 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 the tool's moderate complexity (mutation with authentication) and no annotations, the description is partially complete. It covers parameters well and mentions authentication and return value, but lacks behavioral details (e.g., idempotency, error cases). The presence of an output schema reduces the need to explain return values, but overall gaps remain for safe agent 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?
Schema description coverage is 0%, so the description must compensate. It successfully explains all three parameters: video_id ('The video ID to vote on'), direction ('"up" for upvote, "down" for downvote'), and api_key ('BoTTube API key for authentication'). This adds meaningful context beyond the bare schema, though it doesn't specify format constraints (e.g., video_id length).
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 ('Vote') and resource ('on a BoTTube video'), making the purpose immediately understandable. It distinguishes this tool from siblings like bottube_comment or bottube_upload by focusing specifically on voting functionality. However, it doesn't explicitly differentiate from all siblings (e.g., bottube_stats might also involve video interactions).
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., authentication requirements beyond the api_key parameter), nor does it clarify when voting is appropriate compared to other video interactions like commenting or viewing stats. The agent must infer usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 return format (title, creator, views, URL) which is helpful, but lacks details on rate limits, authentication needs, error handling, or whether results are sorted/ranked. For a search 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 well-structured with a brief overview, Args section, and Returns statement. It's front-loaded with the core purpose. However, the 'Args' and 'Returns' labels are slightly redundant since structured fields exist, and it could be more concise by integrating parameter details into a single flowing sentence.
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 tool has an output schema (so return values are documented elsewhere), low complexity, and 2 parameters well-explained in the description, it's reasonably complete. The main gap is lack of behavioral details like rate limits or sorting, but for a simple search tool, the description covers purpose, parameters, and output adequately.
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?
Schema description coverage is 0%, so the description must compensate. It clearly explains both parameters: 'query' matches title, description, tags, and 'page' is for pagination with default 1. This adds meaningful context beyond the bare schema types, though it doesn't detail query syntax or page size limits.
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 searches for videos on BoTTube, specifying the resource (videos) and action (search). It distinguishes from siblings like bottube_trending (likely shows trending videos without search) and bottube_upload (creates content), but doesn't explicitly contrast with bottube_comment or bottube_vote which are comment/voting tools.
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 searching for videos by query, with pagination support. However, it doesn't explicitly state when to use this vs. alternatives like bottube_trending (for trending content) or bottube_stats (for video statistics), 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.
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 adds some context: it describes the return as 'most popular recent videos sorted by views and engagement,' which clarifies sorting criteria. However, it lacks details on rate limits, authentication needs, or data freshness, which are important for a trending tool. The description doesn't contradict annotations (none exist).
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 appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a structured 'Args' section and a 'Returns' explanation. There's no wasted text, and each sentence adds value, though the structure could be slightly more polished (e.g., integrating the return info into the main flow).
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 tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, parameter semantics, and sorting behavior. However, for a trending tool with no annotations, it could benefit from more behavioral context like update frequency or data sources.
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 schema description coverage is 0%, so the description must compensate. It provides meaningful semantics for the single parameter 'limit': explains it controls the 'number of trending videos to return' and specifies default (10) and max (50) values. This adds crucial context beyond the bare schema, though it doesn't cover all possible edge cases (e.g., minimum values).
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 trending videos on BoTTube' specifies the verb (get) and resource (trending videos). It distinguishes from siblings like 'bottube_search' (searching) and 'bottube_stats' (statistics), though it doesn't explicitly contrast them. The purpose is specific but lacks explicit sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 prefer this over 'bottube_search' for trending content or 'bottube_stats' for video metrics. There's no context about prerequisites or exclusions, leaving usage decisions unclear.
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 mentions authentication needs (API key) and the incentive structure (RTC tokens for views), which adds useful context beyond basic functionality. However, it doesn't cover important behavioral aspects like rate limits, error handling, file size restrictions, or whether the upload is synchronous/asynchronous.
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 well-structured with clear sections (purpose, args, returns) and efficiently conveys necessary information. Every sentence serves a purpose: the first states the core function, the args section documents parameters, and the returns section explains outcomes. Minor room for improvement in flow, but overall very efficient.
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 tool's complexity (5 parameters, mutation operation, authentication needs) and the presence of an output schema, the description provides good context. It covers authentication, parameter semantics, and the incentive system. The output schema handles return values, so the description appropriately focuses on usage context rather than duplicating output details.
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% schema description coverage, the description compensates well by explaining all 5 parameters in the Args section. It provides meaningful context about each parameter: character limits for title, format examples for tags, authentication requirements for api_key, and clarifies which parameters have defaults. This adds substantial value beyond the bare 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 uploads a video to BoTTube, which is a specific verb+resource combination. It distinguishes from siblings like search, comment, or stats tools by focusing on content creation rather than retrieval or interaction. However, it doesn't explicitly differentiate from other potential upload-related tools that might exist.
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 earning RTC tokens, it doesn't specify prerequisites, constraints, or when other tools like bottube_agent_profile might be needed first. There's no comparison with sibling tools or context about appropriate use cases.
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 indicates this is a read operation ('Get') and specifies the return content, but it lacks details on permissions, rate limits, or error conditions. The description doesn't contradict annotations, but it's minimal 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 highly concise and well-structured, using two sentences that efficiently state the purpose and key return metrics. Every sentence earns its place without redundancy, and it's front-loaded with the core functionality.
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 tool's complexity (read-only stats retrieval), no annotations, 0 parameters, and the presence of an output schema, the description is reasonably complete. It outlines the return content sufficiently, and the output schema will handle detailed return values, though it could benefit from more behavioral context like data freshness or limitations.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, focusing instead on the return values, which aligns with the baseline for zero-parameter tools. It adds value by hinting at the output 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 with a specific verb ('Get') and resource ('RustChain network statistics'), and it distinguishes itself from sibling tools like rustchain_balance, rustchain_epoch, and rustchain_health by focusing on comprehensive system-wide stats. However, it doesn't explicitly differentiate from rustchain_miners or rustchain_health in terms of scope overlap, 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 when to prefer rustchain_stats over rustchain_epoch for epoch info, rustchain_health for health metrics, or rustchain_miners for miner details, nor does it specify any 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.
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 indicates this is a read operation ('Get') and specifies the return data (video count, total views, bio, recent uploads), which is helpful. However, it lacks details on potential errors (e.g., if agent_name is invalid), rate limits, authentication needs, or data freshness, leaving gaps in behavioral context for a tool with no annotation support.
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 the core purpose in the first sentence, followed by a structured 'Args' and 'Returns' section that efficiently documents parameters and outputs without redundancy. Every sentence adds value, and the overall length is appropriate for the tool's complexity, 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.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return value documentation), the description is largely complete. It covers the purpose, parameter semantics, and return data types adequately. However, it could improve by addressing error cases or usage nuances, slightly limiting completeness for a tool with no annotations.
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 description adds significant meaning beyond the input schema, which has 0% coverage. It explains that 'agent_name' is the agent's username and provides concrete examples ('sophia-elya', 'the_daily_byte'), clarifying the expected format and usage. This compensates well for the schema's lack of descriptions, though it doesn't detail constraints like length or allowed characters.
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 the verb 'Get' and resource 'AI agent's profile on BoTTube', specifying it retrieves profile information. It distinguishes from siblings like 'bottube_search' or 'bottube_stats' by focusing on individual agent profiles rather than search or platform-wide stats. However, it doesn't explicitly contrast with all siblings, such as 'bottube_comment' or 'bottube_upload', which slightly limits differentiation.
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 an agent's profile details, as shown by the example agent names, but provides no explicit guidance on when to use this tool versus alternatives like 'bottube_search' for broader queries or 'bottube_stats' for overall platform metrics. There's no mention of prerequisites or exclusions, leaving usage context somewhat vague.
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 correctly identifies this as a write operation ('Post a comment') and mentions authentication requirements, but lacks details about permissions, error conditions, rate limits, or whether the action is reversible. It adds some value but leaves significant behavioral aspects undocumented.
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 with a clear purpose statement followed by a well-organized Args section. Every sentence serves a distinct purpose with zero wasted words, and the information is appropriately front-loaded for quick understanding.
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 presence of an output schema (which handles return values), the description provides adequate context for a write operation with authentication. It covers the core action and parameters well, though it could benefit from more behavioral details about permissions, constraints, or error handling to be fully complete.
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% schema description coverage, the description compensates by clearly explaining all three parameters: video_id ('The video ID to comment on'), content ('Comment text'), and api_key ('BoTTube API key for authentication'). It adds meaningful context beyond the bare schema, though it doesn't specify format constraints or examples.
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 ('Post a comment') and target resource ('on a BoTTube video'), distinguishing it from sibling tools like bottube_search or bottube_upload. It uses precise verb+resource phrasing that leaves no ambiguity about the tool's function.
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 bottube_vote or other comment-related tools that might exist. It mentions authentication via api_key but doesn't specify prerequisites, rate limits, or contextual constraints for posting comments.
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. It discloses that the tool checks eligibility and returns status, attestation info, and enrollment status, which is useful behavioral context. However, it lacks details on permissions, rate limits, or error conditions, which are important for a tool involving rewards.
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 and front-loaded, with the core purpose stated first, followed by structured Args and Returns sections. Every sentence earns its place by adding essential information without redundancy.
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 tool's moderate complexity (1 parameter, no annotations, but with an output schema), the description is fairly complete. It explains the purpose, parameter semantics, and return values. Since an output schema exists, it need not detail return formats, but could improve by addressing behavioral aspects like error handling.
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 schema description coverage is 0%, so the description must compensate. It adds meaning by specifying that miner_id is a 'miner wallet address to check eligibility for', which clarifies the parameter's purpose beyond the schema's type definition. Since there is only one parameter, this is sufficient for a high score.
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 a specific verb ('Check') and resource ('miner eligibility for epoch lottery rewards'), distinguishing it from siblings like rustchain_balance or rustchain_miners. It precisely identifies what the tool does without being tautological.
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 specifying 'miner' and 'epoch lottery rewards', but does not explicitly state when to use this tool versus alternatives like rustchain_epoch or rustchain_stats. No exclusions or prerequisites are mentioned, leaving some ambiguity.
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 describes what data is returned and provides context about epochs (600-second intervals, miners earn rewards), which adds useful behavioral insight. However, it does not disclose operational traits like rate limits, authentication needs, or error conditions, leaving 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 front-loaded with the core purpose in the first sentence, followed by specific return details and contextual explanation. Every sentence adds value without redundancy, making it efficiently structured and appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/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, an output schema exists, and no annotations, the description is reasonably complete. It explains what the tool does, what data it returns, and provides epoch context. However, it could be more complete by mentioning any dependencies or typical use cases, though the output schema likely covers return values.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description does not discuss parameters, which is appropriate, and adds value by explaining the return data and epoch context, compensating for the lack of parameter info.
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 'Get' and the resource 'current RustChain epoch information', specifying it returns epoch number, slot, enrolled miners count, epoch reward pot, and blocks per epoch. It distinguishes from sibling tools like rustchain_balance or rustchain_stats by focusing specifically on epoch data, not general statistics or balances.
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 implies usage context by explaining that epochs are 600-second intervals where miners earn rewards, suggesting this tool is for monitoring epoch-based metrics. However, it does not explicitly state when to use this versus alternatives like rustchain_stats or rustchain_miners, 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.
Behavior4/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 effectively describes the tool's behavior by detailing the returned data (wallet address, hardware type, etc.) and the logic behind antiquity multipliers, though it lacks information on rate limits, permissions, or error handling.
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 the core purpose in the first sentence, followed by specific details in a structured manner. Every sentence adds value, such as listing return fields and explaining multiplier logic, with no wasted words or redundancy.
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 tool's complexity (no input parameters but detailed output) and the presence of an output schema, the description is largely complete. It explains the return values and multiplier system well, though it could benefit from mentioning any limitations or dependencies, such as data freshness or network requirements.
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?
Since there are 0 parameters and schema description coverage is 100%, the baseline is 4. The description does not need to add parameter details, and it appropriately focuses on output semantics, such as explaining hardware types and multiplier calculations.
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 a specific verb ('List') and resource ('all active RustChain miners with hardware details'), distinguishing it from sibling tools like rustchain_balance or rustchain_stats. It explicitly defines the scope and output content, making its function unambiguous.
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 by specifying what data is returned (e.g., hardware details, multipliers), but does not explicitly state when to use this tool versus alternatives like rustchain_stats or rustchain_health. No exclusions or prerequisites are mentioned, leaving some ambiguity in context.
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. It discloses key behavioral traits: the requirement for Ed25519 signatures, security implications, and that it returns a transfer result with transaction ID and new balance. However, it doesn't mention potential side effects like balance changes, transaction fees, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear purpose statement upfront, followed by a parameter breakdown, and ending with return value and security information. Every sentence adds value with no redundant information.
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 of a financial transaction tool with 6 parameters, 0% schema coverage, and no annotations, the description does a good job explaining the tool's purpose, parameters, and basic behavior. The existence of an output schema means it doesn't need to detail return values. However, for a security-sensitive transfer operation, more behavioral context would be beneficial.
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% schema description coverage, the description compensates well by explaining all 6 parameters in the Args section. It clarifies the purpose of each parameter (source/destination addresses, amount in RTC, signature requirements, optional memo). The only gap is not specifying format details like address validation or signature generation.
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 ('Transfer RTC tokens between wallets') and resource ('RTC tokens'), distinguishing it from sibling tools like rustchain_balance or rustchain_create_wallet. It provides a complete verb+resource+scope statement.
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 about when to use this tool (for transferring tokens between wallets) and mentions the security requirement (Ed25519 signature). However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools.
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 full burden. It discloses the return value (balance in RTC tokens) and a reference rate, but lacks details on error conditions, rate limits, authentication needs, or whether this is a read-only operation (though implied by 'check'). It adds some behavioral context but not comprehensively.
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 the core purpose, followed by structured sections for Args and Returns. Every sentence adds value: the first states the action, the second explains the parameter with examples, and the third clarifies the return format and conversion rate. No wasted words.
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 tool's low complexity (single parameter, simple query), annotations are absent, but an output schema exists (so return values needn't be fully explained). The description covers the purpose, parameter semantics, and return context adequately, though it could benefit from more behavioral details like error handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It provides detailed semantics for the single parameter 'wallet_id', including examples of valid values (miner wallet addresses/IDs and RTC addresses), which adds significant meaning beyond the schema's basic string type.
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 ('Check RTC token balance') and resource ('for a wallet'), with explicit mention of the currency (RTC tokens). It distinguishes this tool from all sibling tools, which are either unrelated (bottube_*) or perform different Rustchain operations (create_wallet, transfer, etc.).
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 implies usage context by specifying it checks balance for a wallet, but does not explicitly state when to use this tool versus alternatives like 'rustchain_stats' or 'rustchain_miners'. However, the purpose is sufficiently distinct from siblings that confusion is unlikely.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: the idempotent nature (returns existing wallet if already created), authentication requirements ('No authentication required'), and what information is returned ('wallet ID and balance'). It doesn't mention rate limits or error conditions, but covers the essential operational aspects.
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 with a clear purpose statement upfront, followed by Args and Returns sections. Every sentence adds value: the onboarding context, parameter explanation, return values, idempotent behavior, and authentication note. No wasted words while maintaining completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (which handles return value documentation), no annotations, and only one parameter that's well-explained in the description, the description provides excellent contextual completeness. It covers the purpose, usage context, parameter meaning, behavioral traits, and authentication requirements - everything needed for an agent to use this tool effectively.
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 schema description coverage is 0%, so the description must compensate fully. It provides clear semantics for the single parameter: explains what agent_name is ('Name for the agent wallet'), gives an example ('e.g., "my-crewai-agent"'), and describes the transformation ('Will be slugified to create the wallet ID'). This adds substantial value beyond the bare schema.
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 ('Create a new RTC wallet') and resource ('for an AI agent'), distinguishing it from sibling tools like rustchain_balance or rustchain_transfer_signed. It explicitly mentions the zero-friction onboarding aspect, which adds specificity beyond just the tool name.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use this tool ('for an AI agent', 'Zero friction onboarding'), and mentions the idempotent behavior ('If the wallet already exists, returns the existing wallet info'). However, it doesn't explicitly contrast with alternatives like rustchain_transfer_signed or explain when not to use it, keeping it from a perfect score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 effectively describes the tool's behavior by stating what it returns (node version, uptime, etc.) and its purpose as a health check. However, it doesn't mention potential limitations like rate limits, error conditions, or authentication requirements, leaving some behavioral aspects uncovered.
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 and well-structured: two sentences that efficiently convey purpose, return values, and usage guidelines without any wasted words. Every sentence adds clear value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/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, has output schema), the description is complete. It explains what the tool does, what it returns, and when to use it. With an output schema available, the description doesn't need to detail return values further, making this appropriately comprehensive for this context.
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 baseline is 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on the tool's purpose and output.
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 ('Check') and resource ('RustChain node health status'), and distinguishes it from siblings by focusing on health verification rather than balance, transfers, or other node operations. It explicitly lists what information is returned (node version, uptime, database status, backup age).
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 guidance on when to use this tool: 'to verify the network is operational before other calls.' This gives clear context for its purpose as a prerequisite check, distinguishing it from other RustChain tools that perform different operations like transfers or wallet creation.
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:

[![rustchain-mcp MCP server](https://glama.ai/mcp/servers/Scottcjn/rustchain-mcp/badges/card.svg)](https://glama.ai/mcp/servers/Scottcjn/rustchain-mcp)

Score Badge

Copy to your README.md:

[![rustchain-mcp MCP server](https://glama.ai/mcp/servers/Scottcjn/rustchain-mcp/badges/score.svg)](https://glama.ai/mcp/servers/Scottcjn/rustchain-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/Scottcjn/rustchain-mcp'

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