MCP Bitcoin CLI

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, such as broadcast_transaction for sending transactions and get_node_info for node status. However, there is some overlap between embed_document and encode_op_return, both preparing data for embedding, which could cause minor confusion. Overall, the descriptions clarify differences, but a few tools have similar scopes.
Naming Consistency4/5
The naming follows a consistent verb_noun pattern throughout, like broadcast_transaction and decode_op_return, with clear and descriptive names. There are minor deviations, such as get_node_info using 'get' while others use verbs like 'create' or 'list', but the pattern remains largely predictable and readable.
Tool Count4/5
With 16 tools, the count is slightly high but reasonable for a Bitcoin CLI server covering transactions, tokens, documents, and network operations. It feels comprehensive without being overwhelming, though it borders on heavy for the scope. Each tool appears to serve a specific function, justifying its inclusion.
Completeness4/5
The toolset provides good coverage for Bitcoin operations, including transaction handling, token management (BRC-20), document embedding, and network queries. Minor gaps exist, such as no direct tools for wallet management or advanced blockchain queries, but core workflows like creating, broadcasting, and verifying are well-supported, allowing agents to work effectively.
Average 3.3/5 across 16 of 16 tools scored. Lowest: 2.6/5.
See the Tool Scores section below for per-tool breakdowns.
- 1 of 11 community issues answered or closed in the last 6 months
- 2 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 failing
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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Fetch' implies a read operation, the description doesn't address important behavioral aspects like authentication requirements, rate limits, error conditions, or what happens when an invalid transaction ID is provided. The description mentions a return format ('Dictionary with transaction details') but doesn't specify what fields this dictionary contains.
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 concise with a clear three-part structure: purpose statement, parameter documentation, and return value description. Each sentence serves a distinct purpose with minimal redundancy. The formatting with clear sections for Args and Returns enhances readability.
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 retrieval tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what transaction details are returned, what blockchain or system this operates on, error handling, or authentication requirements. Given the complexity of transaction data and the lack of structured documentation, the description should provide more context about the operation's scope and limitations.
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 basic semantic information about the single parameter ('Transaction ID (hash)'), but with 0% schema description coverage, it doesn't fully compensate for the lack of schema documentation. The description doesn't specify the expected format of the transaction ID (e.g., hex string, length requirements) or provide examples. Since there's only one parameter, the baseline is higher than it would be for multiple undocumented parameters.
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 ('Fetch transaction details') which is a clear verb+resource combination, but it doesn't differentiate this tool from potential sibling tools that might also retrieve transaction information. The description is adequate but lacks specificity about what distinguishes this particular transaction fetch operation.
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 about when to use this tool versus alternatives. With multiple sibling tools available (like broadcast_transaction, decode_op_return, parse_envelope), there's no indication of when get_transaction is the appropriate choice versus other transaction-related 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 the full burden of behavioral disclosure. It states the tool creates an inscription, implying a write operation, but lacks details on permissions, side effects, rate limits, or error handling. This is inadequate for a mutation tool with zero 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the main purpose, followed by structured sections for args and returns. It avoids unnecessary fluff, though the formatting with indentation could be slightly cleaner for readability.
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 creating a token transfer (a mutation operation) with no annotations and no output schema, the description is incomplete. It lacks information on what the inscription entails, how it interacts with the blockchain, error cases, or example outputs, leaving gaps for an AI 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 description adds significant meaning beyond the input schema, which has 0% coverage. It explains that 'tick' is a token ticker with exactly 4 characters and 'amount' is the amount to transfer, clarifying semantics that the schema alone does not provide. However, it doesn't cover units or validation rules for 'amount'.
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 ('Create a BRC-20 token transfer inscription') and resource (token transfer), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'create_token_deploy' or 'create_token_mint', 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 such as 'create_token_deploy' or 'create_token_mint', nor does it mention prerequisites or context for usage. It only lists parameters and returns, leaving usage entirely implied.
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 states what the tool does but doesn't explain what 'create' entails operationally - whether this requires blockchain interaction, incurs fees, has side effects, or returns immediately. For a tool that likely creates blockchain inscriptions, this lack of behavioral context is a significant gap.
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 with a clear purpose statement followed by well-organized Args and Returns sections. Every sentence serves a purpose - the first establishes context, and the parameter documentation is necessary given the schema's lack of descriptions. It could be slightly more concise in the parameter explanations.
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 creating token deployments (likely involving blockchain operations), no annotations, and no output schema, the description is moderately complete. It explains parameters well but lacks crucial behavioral context about what 'create' actually does operationally. The returns section mentions 'dictionary with inscription data' but doesn't detail what that contains, leaving gaps for understanding the tool's full behavior.
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 substantial semantic value beyond the 0% schema description coverage. It explains that 'tick' must be exactly 4 characters, provides examples, clarifies optional/default values for mint_limit and decimals, and gives context about what each parameter represents. This compensates well for the schema's lack of descriptions.
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 'create' and resource 'BRC-20 token deployment inscription', making the purpose immediately understandable. It distinguishes from siblings like create_token_mint and create_token_transfer by specifying this is for deployment rather than minting or transferring tokens. However, it doesn't explicitly contrast with all siblings, so it's not a perfect 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. While it's clear this creates token deployments, there's no mention of prerequisites, when to choose this over other token operations, or what context requires a deployment inscription. Users must infer usage from the purpose 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 the full burden of behavioral disclosure. While 'Create' implies a write operation, the description doesn't address critical aspects like whether this requires network broadcasting, what permissions are needed, if it's irreversible, or potential rate limits. The mention of 'inscription data' hints at output but lacks detail on format or success/failure 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 efficiently structured with a clear opening sentence followed by well-organized 'Args' and 'Returns' sections. Every sentence adds value: the first states the purpose, the second details parameters, and the third outlines the return format, with no redundant or verbose language.
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 creating a token mint (a write operation with blockchain implications), no annotations, and no output schema, the description is incomplete. It lacks information on behavioral traits (e.g., idempotency, error handling), output specifics beyond 'Dictionary with inscription data', and how this integrates with sibling tools like 'broadcast_transaction' for execution.
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 meaningful context for both parameters: 'tick' is explained as a 'Token ticker (exactly 4 characters)' and 'amount' as 'Amount to mint'. With 0% schema description coverage, this compensates well by clarifying constraints (e.g., 4-character limit) and purpose beyond the bare schema, though it doesn't cover all possible semantic nuances like numeric ranges for 'amount'.
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 ('Create') and resource ('BRC-20 token mint inscription'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'create_token_deploy' or 'create_token_transfer', which likely handle different BRC-20 operations.
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 'create_token_deploy' or 'create_token_transfer'. It doesn't mention prerequisites, constraints, or typical use cases for minting tokens versus deploying or transferring them.
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 return format ('Dictionary with 'script_hex' containing the OP_RETURN script'), which is helpful, but lacks details on permissions, rate limits, error handling, or side effects. For a 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 well-structured and concise, with a clear purpose statement followed by parameter and return details in a formatted list. Every sentence adds value, and it's front-loaded with the core functionality. Minor improvements could include briefer formatting, but overall it's efficient.
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 (2 parameters, no annotations, no output schema), the description is moderately complete. It covers purpose, parameters, and returns adequately, but lacks usage guidelines and behavioral details like error cases or integration with sibling tools. For a tool in this context, it meets minimum viability but has clear gaps.
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 meaningful context beyond the input schema, which has 0% description coverage. It explains that 'data' is 'Data to encode (string)' and 'encoding' specifies the format with examples ('utf-8', 'hex') and a default. This compensates well for the schema's lack of descriptions, though it could elaborate on data constraints or encoding implications.
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: 'Encode arbitrary data into OP_RETURN script format.' It specifies the verb ('encode') and resource ('arbitrary data'), making it clear what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'decode_op_return' or 'build_op_return_transaction' beyond the encoding focus.
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 'decode_op_return' (for decoding) or 'build_op_return_transaction' (which might incorporate OP_RETURN encoding), nor does it specify prerequisites or contexts for usage. This leaves the agent without clear direction on 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists UTXOs but does not describe key behaviors such as whether this is a read-only operation, potential rate limits, authentication requirements, or how the output is structured (beyond a vague 'Dictionary with list of UTXOs'). This is inadequate 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.
Conciseness4/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 parameter and return details in a structured format. It avoids unnecessary verbosity, though the inclusion of 'Returns: Dictionary with list of UTXOs' is somewhat vague and could be more precise, but overall it is efficient.
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 (2 parameters, no output schema, no annotations), the description is partially complete. It covers the purpose and parameters adequately but lacks details on behavioral traits, output structure, and usage context. This results in a minimal viable description with clear gaps, especially for a tool with no annotations to supplement it.
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 meaningful semantics beyond the input schema, which has 0% description coverage. It explains that 'min_confirmations' is the 'Minimum confirmations required' and 'min_amount' is the 'Minimum UTXO amount in BTC', including default values. This compensates well for the schema's lack of descriptions, though it could provide more context on units or constraints.
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: 'List available UTXOs for funding transactions.' It specifies the verb ('List') and resource ('UTXOs') with a functional context ('for funding transactions'), which is clear and actionable. However, it does not explicitly differentiate from sibling tools like 'get_transaction' or 'search_op_returns', which might also involve transaction data, so it misses full sibling distinction.
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 'for funding transactions' as a general context, but does not specify prerequisites, exclusions, or compare to sibling tools such as 'get_transaction' for retrieving specific transaction details. This lack of explicit usage instructions leaves 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 states the tool 'retrieves and parses' and returns a dictionary, but doesn't describe what parsing entails, potential error conditions, format of the returned dictionary, or any limitations. For a parsing tool with zero annotation coverage, this 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately concise with two clear sentences stating purpose and return value, plus parameter documentation in a structured Args/Returns format. Every element serves a purpose, though the parameter documentation could be slightly more integrated into the main description flow rather than as a separate block.
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 (parsing operation), no annotations, no output schema, and 0% schema description coverage, the description is minimally adequate. It covers the basic purpose and parameter semantics but lacks details about parsing behavior, error handling, and return format specifics that would be needed for confident tool invocation.
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 meaningful context for the single parameter 'data_hex' by specifying it should be 'hex-encoded document data (from OP_RETURN)', which provides crucial semantic information not present in the schema (which has 0% description coverage). This compensates well for the schema's lack of parameter documentation, though it doesn't detail format constraints or validation rules.
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 ('retrieve and parse') and identifies the resource ('document from transaction data'). It distinguishes from siblings like 'decode_op_return' or 'parse_envelope' by focusing specifically on document content rather than general decoding or envelope parsing. However, it doesn't explicitly contrast with these alternatives in the description text itself.
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 minimal usage guidance. It mentions the source of data ('from OP_RETURN') which implies some context, but doesn't specify when to use this tool versus alternatives like 'decode_op_return' or 'parse_envelope' that also handle OP_RETURN data. No explicit when/when-not guidance or prerequisites are provided.
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 parsing and returning a dictionary, but lacks details on error handling, performance, or limitations (e.g., what happens if the hex is invalid or if UTF-8 decoding fails). For a 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is highly concise and well-structured: a brief purpose statement followed by clear sections for arguments and returns. Every sentence adds value without redundancy, 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 moderate complexity (one parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and parameter, but lacks details on usage context, error handling, and output specifics. Without annotations or an output schema, more behavioral information would improve completeness.
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 meaningful context for the single parameter: 'script_hex: OP_RETURN script as hex string.' Since schema description coverage is 0%, this compensates well by explaining what the parameter represents. However, it doesn't provide examples or constraints (e.g., expected format or length), so it's not fully comprehensive.
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: 'Parse OP_RETURN data from script hex.' It specifies the verb ('parse') and resource ('OP_RETURN data'), making it understandable. However, it doesn't explicitly distinguish this tool from sibling tools like 'parse_envelope' or 'search_op_returns', which might have overlapping functionality, so it doesn't reach 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 a valid OP_RETURN script, or compare it to siblings like 'encode_op_return' or 'search_op_returns'. Without this context, users might struggle to select the right tool in appropriate 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?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the tool prepares documents 'for on-chain storage' but doesn't explain what this entails—whether it modifies content, requires specific permissions, has rate limits, or what 'prepared document data' means operationally. The description lacks critical behavioral context for a tool that likely involves data transformation.
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 well-organized parameter and return sections. Every sentence adds value: the purpose sets context, and the parameter explanations are necessary given the schema gaps. No redundant or verbose content is present.
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 3-parameter tool with no annotations and no output schema, the description is moderately complete. It covers parameter semantics adequately but lacks behavioral details (e.g., what 'prepared' means, error conditions) and return value specifics beyond a generic 'dictionary.' Given the complexity of on-chain operations, more 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 description adds significant semantic value beyond the input schema, which has 0% description coverage. It explains each parameter's purpose: 'content' as document content, 'content_type' as MIME type with default, and 'encoding' as content encoding with options. This compensates well for the schema's lack of descriptions, though it doesn't detail format constraints beyond the encoding enum.
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: 'Prepare a document for on-chain storage.' It specifies the action (prepare) and resource (document) with a specific context (on-chain storage). However, it doesn't explicitly differentiate from sibling tools like 'read_document' or 'parse_envelope' beyond the preparation focus.
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, appropriate contexts, or compare it to siblings like 'encode_op_return' or 'create_timestamp' which might handle similar on-chain data operations. Usage is implied only by the purpose statement.
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 is a placeholder that returns an error indicating the feature requires direct block access, which is crucial behavioral context. However, it lacks details on permissions, rate limits, or error handling beyond this, leaving gaps for a tool with 3 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but not optimally structured. The first sentence is clear, but the note about placeholder status, while important, might be better placed later. The parameter and return sections are helpful but could be more integrated. Overall, it's functional but not perfectly front-loaded.
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 (3 parameters, no annotations, no output schema), the description is moderately complete. It covers the tool's purpose, placeholder status, parameters, and return value. However, for a tool that scans blocks and returns transactions, more details on output format, error cases, or implementation status would enhance completeness.
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 explaining each parameter's purpose: 'start_height' as the starting block height, 'end_height' as optional ending block height with default behavior, and 'limit' as maximum results with a default. This goes beyond the schema's basic types and titles, though it could be more detailed on constraints.
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: 'Scan blocks for OP_RETURN transactions.' It specifies both the verb ('scan') and the resource ('blocks for OP_RETURN transactions'), making the function evident. However, it doesn't explicitly differentiate from siblings like 'decode_op_return' or 'encode_op_return', 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 mentions that it's a placeholder requiring additional implementation, but this doesn't help an agent decide between this and sibling tools like 'decode_op_return' or 'get_transaction'. There's no explicit when/when-not or alternative recommendations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 verifies data against a hash but doesn't describe what 'on-chain timestamp' entails, whether it requires network access, error handling, or the structure of the returned dictionary. For a verification 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.
Conciseness5/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 list of args and returns. Every sentence earns its place by providing essential information without redundancy, making it 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 (4 parameters, no annotations, no output schema), the description is partially complete. It covers the purpose and parameters well but lacks details on behavioral aspects (e.g., how verification works, error cases) and the return value structure. Without an output schema, the description should ideally explain the dictionary's contents, which it doesn't, leaving gaps.
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 meaningful semantics beyond the input schema, which has 0% description coverage. It explains each parameter's purpose (e.g., 'data: Original data to verify', 'encoding: Data encoding') and provides enum-like details for 'encoding' and 'hash_algorithm'. This compensates well for the schema's lack of descriptions, though it doesn't cover all nuances like format constraints.
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: 'Verify data against an on-chain timestamp hash.' It specifies the verb ('verify') and resource ('data against an on-chain timestamp hash'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'create_timestamp' or 'parse_envelope', 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 lists parameters but doesn't explain scenarios for verification, prerequisites (e.g., needing a pre-existing timestamp), or comparisons to siblings like 'decode_op_return' or 'read_document'. This leaves usage context implied at best.
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 full burden. It discloses key behavioral traits: the tool can perform both dry-run testing and actual broadcasting, and it returns different result structures for each mode. However, it lacks critical details like network requirements, error conditions, or confirmation behavior that would be needed for a higher score.
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 for Args and Returns. Each sentence adds value, though the formatting with indentation could be cleaner. The information is front-loaded with the core purpose stated 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?
For a transaction broadcasting tool with no annotations and no output schema, the description does an adequate job explaining parameters and return values. However, it lacks important context about network effects, error handling, and integration with sibling tools, leaving gaps in completeness.
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 must compensate fully. It successfully explains all three parameters: 'tx_hex' as 'Signed transaction as hex string', 'dry_run' with its default and purpose, and 'max_fee_rate' as optional with units. This provides meaningful context 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 action ('Send signed transaction') and resource ('to the network'), making the purpose immediately understandable. However, it doesn't explicitly distinguish this tool from its siblings like 'get_transaction' or 'verify_timestamp', 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 like 'build_op_return_transaction' or 'verify_timestamp'. It mentions dry-run functionality but doesn't explain when to choose dry-run versus actual broadcast, leaving usage context unclear.
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 creates a hash commitment and returns a dictionary, but fails to describe critical behaviors like whether this is a read-only operation, if it requires network access, what happens on failure, or any rate limits. The description is minimal and lacks 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. The parameter and return sections are structured clearly, though the Args/Returns formatting is slightly verbose. Every sentence adds value, with no wasted words.
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 partially complete. It covers the purpose and parameters well but lacks behavioral context, error handling, and output details (beyond a vague 'dictionary'). For a tool that creates commitments, more operational guidance 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 description adds significant meaning beyond the input schema, which has 0% description coverage. It explains each parameter's purpose (data to timestamp, encoding options, hash algorithm choices) and provides enum-like values for encoding and hash_algorithm, compensating for the schema's lack of documentation. However, it doesn't detail format constraints or examples for the data parameter.
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 ('create') and resource ('hash commitment for timestamping'), distinguishing it from sibling tools like verify_timestamp (which validates) or embed_document (which embeds). It precisely defines what the tool produces.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 embed_document or verify_timestamp. It lacks context about prerequisites, typical use cases, or exclusions, leaving the agent to infer usage from the purpose 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 states the tool parses data but doesn't cover error handling (e.g., invalid hex), performance traits (e.g., speed or limits), or side effects. This leaves gaps in understanding how the tool behaves beyond its basic function.
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 Args and Returns sections. Every sentence earns its place by providing essential information without redundancy, making it efficient and well-organized for quick understanding.
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 (parsing binary data), no annotations, and no output schema, the description is partially complete. It covers the purpose and return format but lacks details on error cases, input validation, or behavioral traits, which are important for a parsing tool with unstructured inputs.
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 specifies that data_hex is 'Hex-encoded envelope data', clarifying the format and purpose, though it could detail constraints like length or valid characters. With one parameter and low schema coverage, this compensation is strong but not exhaustive.
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 ('Parse') and target resource ('BTCD envelope structure from raw bytes'), distinguishing it from sibling tools like decode_op_return or read_document. It precisely defines what the tool does without being vague or tautological.
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 decode_op_return or verify_timestamp. It lacks context about prerequisites, such as needing raw bytes from a specific source, and doesn't mention any exclusions or complementary 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the return format ('Dictionary with node information including connection status, network, block height, and version'), which adds value beyond the input schema. However, it doesn't cover other behavioral traits such as error conditions, performance characteristics, or side effects. The description is helpful but incomplete for a tool with zero 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 ('Check connection and network status') and efficiently follows with return value details in a structured format. Every sentence earns its place, and there is no wasted verbiage. The use of a clear 'Returns:' section enhances readability without adding bulk.
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, no output schema), the description is reasonably complete for a diagnostic tool. It explains what the tool does and what it returns. However, without annotations or an output schema, it could benefit from more detail on error handling or specific use cases to fully compensate for the lack of structured data.
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 input schema has 100% description coverage (though empty). The description doesn't need to add parameter semantics, so it meets the baseline of 4 for zero-parameter tools. It appropriately focuses on the tool's purpose and output 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 with specific verbs ('Check connection and network status') and identifies the resource ('node information'). It distinguishes from siblings by focusing on diagnostic/status checking rather than transaction creation, token operations, or data retrieval. However, it doesn't explicitly differentiate from all siblings (e.g., 'verify_timestamp' might also involve status checking).
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 through the phrase 'Check connection and network status,' suggesting this tool should be used for diagnostic or health-check purposes. However, it doesn't provide explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or exclusions. The context is clear but lacks detailed comparative guidance.
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 full burden. It clearly states this is a preparation/construction tool that doesn't broadcast transactions, which is valuable behavioral context. However, it doesn't mention error conditions, rate limits, or what happens with invalid inputs. The description adds meaningful context but lacks comprehensive behavioral disclosure.
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?
Perfectly structured with purpose statement first, followed by important behavioral constraint, then organized parameter documentation, and finally return value. Every sentence earns its place with zero wasted words. The information is front-loaded with the most critical details first.
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?
For a 4-parameter tool with no annotations and no output schema, the description does well by explaining parameters and return value. However, it could provide more context about error cases or edge conditions. Given the complexity and lack of structured documentation elsewhere, it's mostly complete but has minor gaps.
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 must compensate, which it does effectively. It explains all 4 parameters with clear semantics: 'data' is 'Data to embed', 'encoding' specifies format options, 'use_envelope' controls wrapping behavior, and 'envelope_type' enumerates specific envelope options. 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 ('Construct OP_RETURN output data for a transaction') and resource ('OP_RETURN output data'), distinguishing it from siblings like broadcast_transaction (which actually sends transactions) and decode_op_return (which interprets existing data). The first sentence precisely defines 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 Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when NOT to use this tool ('does not create or broadcast the transaction itself'), providing clear boundaries. It also implies when to use it (when preparing data for inclusion) and suggests alternatives like broadcast_transaction for the next step in the workflow.
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:

[![mcp-bitcoin-cli MCP server](https://glama.ai/mcp/servers/EricGrill/mcp-bitcoin-cli/badges/card.svg)](https://glama.ai/mcp/servers/EricGrill/mcp-bitcoin-cli)

Score Badge

Copy to your README.md:

[![mcp-bitcoin-cli MCP server](https://glama.ai/mcp/servers/EricGrill/mcp-bitcoin-cli/badges/score.svg)](https://glama.ai/mcp/servers/EricGrill/mcp-bitcoin-cli)

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/EricGrill/mcp-bitcoin-cli'

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