Browse traits, filter 10K punks, listings, bids, Merkle roots, and bid pricing for CryptoPunks.
Glama MCP Gateway
Connect through Glama MCP Gateway for full control over tool access and complete visibility into every call.
Full call logging
Every tool call is logged with complete inputs and outputs, so you can debug issues and audit what your agents are doing.
Tool access control
Enable or disable individual tools per connector, so you decide what your agents can and cannot do.
Managed credentials
Glama handles OAuth flows, token storage, and automatic rotation, so credentials never expire on your clients.
Usage analytics
See which tools your agents call, how often, and when, so you can understand usage patterns and catch anomalies.
Average 4.2/5 across 11 of 11 tools scored.
Every tool targets a distinct resource or action: trait/type browsing, punk metadata, listings/floor price, bids by root/punk, Merkle computation/filtering/resolution, and bid recommendations. The related Merkle tools have clear boundaries: compute builds a root from IDs, filter returns IDs for a trait selection, and resolve reverses a root only if it has bids.
All tool names follow a consistent `verb_noun` pattern in snake_case (e.g., browse_traits, get_floor_price, resolve_merkle_root). The two bid lookup tools use the same `get_bids_for_X` structure, reinforcing predictability.
Eleven tools is well within the ideal 3-15 range and each covers a necessary facet of the CryptoPunks domain—from market data (listings, floor) to trait-based bid analysis (merkle roots, recommendations). No redundancy or bloat.
The tool surface covers the full read-side lifecycle: viewing traits/types/punks, checking market prices/listings, analyzing existing bids, and supporting trait-based bid strategies through Merkle root operations and recommendations. It lacks write actions (e.g., placing bids), but the server's purpose is clearly analytical, so no obvious operational gap exists.
browse_traitsAList all CryptoPunk traits with their counts. Optionally filter by type to see how many punks of that type have each trait. Rate limit: 10 per 10 min (read bucket — shared with browse_types, get_punk_details, get_listings, get_floor_price, get_bids_for_punk, get_bids_for_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
| type | No | Filter counts to a specific type (e.g. 'Male', 'Zombie') |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation is supplemented with the rate limit (10 per 10 min) and the shared read bucket, adding valuable behavioral context beyond the annotation. No contradictory statements exist.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact: one sentence for the core purpose and one sentence for the optional filter and rate limit. Every word serves a purpose, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with one optional parameter, this description fully covers selection and invocation. It explains the result (trait counts), filter behavior, and rate limiting, making it complete despite no output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes the type parameter, but the description enriches it by clarifying the output: 'see how many punks of that type have each trait.' This adds meaning beyond the schema's filter description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with a specific verb+resource: 'List all CryptoPunk traits with their counts.' This clearly distinguishes the tool from siblings like browse_types (traits vs. types) and filter_punks, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by explaining the optional type filter and the rate limit shared with other read tools. However, it does not explicitly state when to prefer this over browse_types or filter_punks, relying on implied differentiation rather than direct alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
browse_typesAList all CryptoPunk type categories with their counts. Rate limit: 10 per 10 min (read bucket — shared with browse_traits, get_punk_details, get_listings, get_floor_price, get_bids_for_punk, get_bids_for_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description goes beyond by specifying a concrete rate limit (10 per 10 min) and naming the shared read bucket with six other tools. This adds valuable operational behavior not present in the annotations, with no contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states the core action, and the second adds a critical operational constraint. It is succinct, front-loaded, and every word earns its place with no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only listing tool, the description is fully complete: it states exactly what it returns (type categories with counts) and a critical operational detail (shared rate limit). No output schema is necessary because the return value is straightforward.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the input schema is empty, so the description does not need to explain parameter semantics. The baseline for zero parameters is 4, and the description appropriately focuses on functionality and rate limits.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with 'List all CryptoPunk type categories with their counts,' which uses a specific verb ('List'), a clear resource ('type categories'), and the output ('counts'). This distinguishes it from sibling tool browse_traits, which likely handles trait categories.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context by specifying that it lists all type categories, which implies when to use it. However, it does not explicitly mention alternatives or exclusions, such as 'for traits, use browse_traits instead.' The rate limit sharing information gives additional operational context but not direct usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
compute_merkle_rootACompute the Merkle root for a set of CryptoPunk IDs. The root matches the on-chain Solady MerkleProofLib encoding used by the Stash contract. Rate limit: 5 per 10 min (compute bucket — shared with filter_punks, resolve_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
| punkIds | Yes | Punk IDs to include in the Merkle tree (1-10000) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already indicates a safe read-only operation. The description adds valuable context about the on-chain Solady MerkleProofLib encoding and a detailed rate limit shared with siblings, going beyond the annotation. No contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight, information-dense sentences: the core action, the encoding context, and the rate-limit constraint. No verbose phrasing or redundant details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, encoding standard, and operational limits, but omits any mention of the return value format or error behavior. Since there is no output schema, this is a gap, though the simple tool and the name partially compensate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides a complete description of the punkIds parameter (100% coverage), so the description does not need to add much. It only repeats that IDs are included without adding any new parameter meaning, warranting the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool computes a Merkle root from a set of CryptoPunk IDs, using a specific verb and resource. However, it does not differentiate from the sibling tool resolve_merkle_root, so it lacks explicit sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or alternative guidance is provided. The purpose implies usage when a Merkle root is needed, but there is no mention of how this relates to resolve_merkle_root or when one should be preferred over the other, despite sharing a rate-limit bucket.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
filter_punksAFilter CryptoPunks by type and traits. Returns matching punk IDs and their Merkle root. Rate limit: 5 per 10 min (compute bucket — shared with compute_merkle_root, resolve_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
| types | No | Type names to include (e.g. ['Male', 'Zombie']). Empty = all types. | |
| matchMode | No | 'all' = punk must have every included trait, 'any' = at least one | all |
| excludedTraits | No | Traits to exclude | |
| includedTraits | No | Traits to include |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, but the description adds valuable behavioral context: it discloses the rate limit, the shared compute bucket, and the return format (punk IDs and Merkle root). This goes beyond the annotation and provides operational details without any contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded: the first sentence states exactly what the tool does and its output, and the second adds the rate limit. Every word earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity, the lack of an output schema, and rich parameter schema, the description covers the essential context: what it filters, what it returns, and the rate limit constraint. It could mention pagination or result size limits, but the read-only annotation and clear return description make it sufficiently complete for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the schema already provides detailed descriptions for every parameter, including the matchMode enum with explanations. The description only offers a high-level summary ('by type and traits') and does not add extra meaning beyond what the schema already conveys, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Filter') with a clear resource ('CryptoPunks') and specifies the return value ('matching punk IDs and their Merkle root'). It clearly distinguishes this from sibling tools like browse_traits and compute_merkle_root by focusing on filtering while explicitly linking to related compute tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys usage context by stating the rate limit and shared compute bucket with compute_merkle_root and resolve_merkle_root, implying to use sparingly and coordinating with those tools. However, it does not explicitly state when to use this tool versus alternatives, so it stops short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_bid_recommendationAAnalyze market data and recommend a bid price range for a CryptoPunk trait selection. Combines floor price, competing bids, and set composition into actionable guidance. composition lists only the traits that define the selection; use absentTraits for a full exclusion list when needed. Rate limit: 1 per 1 min (recommend bucket).
| Name | Required | Description | Default |
|---|---|---|---|
| types | No | Type names to filter (e.g. ['Male', 'Zombie']) | |
| punkIds | No | Explicit punk IDs (overrides trait filters) | |
| matchMode | No | all | |
| excludedTraits | No | Traits to exclude | |
| includedTraits | No | Traits to include |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable behavioral context beyond the readOnlyHint annotation: it explains that the tool combines floor price, competing bids, and set composition, and discloses a rate limit of 1 per 1 minute. It does not mention return format or side effects, but for a read-only recommendation tool, the added context is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the main purpose. However, the sentence about `composition`/`absentTraits` is cryptic and adds confusion without clearly earning its place. Overall, it is still compact and structured, but the misleading term reduces clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description should explain what the response contains; it only implies a bid price range but doesn't specify the structure. The parameter interactions and the odd `absentTraits` reference leave gaps. Given the tool's moderate complexity, the description is not fully complete, though it covers the core purpose and rate limit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description references `composition` and `absentTraits`, neither of which exist in the input schema (which has `includedTraits` and `excludedTraits`). This is misleading because an agent might try to pass `absentTraits` as a parameter, but the schema has additionalProperties: false, so it would be rejected. The description does not clarify the actual parameters beyond what the schema already states, and the erroneous instruction detracts from schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Analyze market data and recommend a bid price range for a CryptoPunk trait selection,' giving a specific verb ('recommend') and resource (bid price range). It distinguishes itself from sibling tools like get_floor_price or get_bids_for_punk by combining multiple data sources into actionable guidance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context for when to use the tool (for a CryptoPunk trait selection) and includes a rate limit warning, but it does not explicitly state when to prefer this over siblings or exclude situations. The note about 'use `absentTraits` for a full exclusion list' is potentially confusing because `absentTraits` is not a valid input parameter in the schema, so it misleads rather than guides.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_bids_for_merkle_rootAGet pending EIP-712 bids matching a specific Merkle root. Useful for seeing competition on a trait-based bid set. Rate limit: 10 per 10 min (read bucket — shared with browse_types, browse_traits, get_punk_details, get_listings, get_floor_price, get_bids_for_punk).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max bids to return (default 5) | |
| merkleRoot | Yes | Merkle root (0x-prefixed, 32 bytes hex) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds important behavioral context beyond the readOnlyHint annotation, specifically the rate limit: 'Rate limit: 10 per 10 min (read bucket — shared with browse_types, browse_traits, get_punk_details, get_listings, get_floor_price, get_bids_for_punk).' This informs the agent of usage constraints and shared quota, which is valuable. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose, then a use case and rate limit. Every sentence adds value, and there is no redundancy or excess. It is concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only tool with two parameters and no output schema, the description covers the essential aspects: purpose, use case, and rate limit. It does not describe the return format or pagination, but given the simplicity and the annotations, it is reasonably complete. The shared read bucket detail adds operational context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with descriptions for both parameters (merkleRoot and limit). The description itself does not add significant meaning beyond the schema, but it reinforces the purpose by mentioning 'specific Merkle root.' Baseline of 3 is appropriate given the high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Get pending EIP-712 bids matching a specific Merkle root.' This uses a specific verb ('Get'), a specific resource ('pending EIP-712 bids'), and a specific qualifier ('matching a specific Merkle root'). It also adds context about its use case ('seeing competition on a trait-based bid set'), which distinguishes it from sibling tools like get_bids_for_punk.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use the tool: 'Useful for seeing competition on a trait-based bid set.' This implies a specific scenario but does not explicitly name alternatives or exclusions. It doesn't say 'use get_bids_for_punk instead' or 'not for direct punk bids,' but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_bids_for_punkAGet pending EIP-712 bids that include a specific CryptoPunk. Returns bids from the CryptoPunks Bids API. Rate limit: 10 per 10 min (read bucket — shared with browse_types, browse_traits, get_punk_details, get_listings, get_floor_price, get_bids_for_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max bids to return (default 5) | |
| punkId | Yes | Punk ID to look up bids for |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true, and the description adds valuable behavioral context: it specifies the rate limit (10 per 10 min) and shared read bucket, which is beyond what annotations provide. It also clarifies the bid type (pending EIP-712) and API source.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core purpose, followed by the rate limit. Every word earns its place with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with complete schema and annotations, the description is sufficient. It includes purpose, data source, and rate limit. No output schema exists, but the description indicates it returns bids, which is adequate for this tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters documented. The description adds context about the bid type and API but does not add new meaning to the parameters themselves. Baseline 3 is appropriate given full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Get'), a specific resource ('pending EIP-712 bids that include a specific CryptoPunk'), and differentiates from the sibling tool get_bids_for_merkle_root by focusing on punkId. It also clarifies the data source (CryptoPunks Bids API).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (you need a specific punkId to look up bids), but it does not explicitly state when to use this tool versus alternatives like get_bids_for_merkle_root or provide exclusions. The rate-limit sharing info is useful but not a usage guideline.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_floor_priceAGet the current floor ask price from the native CryptoPunks marketplace. Excludes restricted (onlySellTo) and zero-value listings. Returns totalActive (same denominator as get_listings). Rate limit: 10 per 10 min (read bucket — shared with browse_types, browse_traits, get_punk_details, get_listings, get_bids_for_punk, get_bids_for_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds valuable behavioral context: it excludes restricted and zero-value listings, returns totalActive with the same denominator as get_listings, and specifies a rate limit with a shared bucket. This goes beyond the annotation to inform about constraints and output semantics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences and front-loads the core purpose. The rate-limit sentence is slightly verbose with its list of shared tools, but it is still clear and compact enough not to distract from the main function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a no-parameter read-only tool with no output schema, the description covers essential context: return field, exclusions, and rate limits. It could be more explicit about the full output structure, but the mention of totalActive and the denominator suffices for a simple floor-price query.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema already fully covers inputs with 100% coverage. The description does not need to elaborate on parameters, but it clarifies the output meaning (totalActive), which adds useful context beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets the current floor ask price from the native CryptoPunks marketplace, with specific exclusions. This distinct purpose separates it from sibling tools like get_listings or get_bids_for_punk.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for obtaining the floor price and notes a shared rate limit with other read tools, but it does not explicitly explain when to choose this over alternatives like get_listings. No direct 'use this when' or 'instead of' guidance is given, only inferred context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_listingsAGet currently listed CryptoPunks from the native marketplace. By default returns only publicly buyable listings (excludes restricted onlySellTo and zero-value entries); pass includeRestricted: true to include private bundle sales. Optionally filter by price range. Returns totalActive (publicly buyable listings, same denominator as get_floor_price) and matchedCount (after your filters). Rate limit: 10 per 10 min (read bucket — shared with browse_types, browse_traits, get_punk_details, get_floor_price, get_bids_for_punk, get_bids_for_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Max results (default 50) | |
| maxPriceEth | No | Maximum price in ETH | |
| minPriceEth | No | Minimum price in ETH | |
| includeRestricted | No | Include restricted (onlySellTo) and zero-value listings. Default false — matches get_floor_price. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the `readOnlyHint: true` annotation, the description discloses the default exclusion of restricted and zero-value listings, the effect of `includeRestricted`, the meaning of `totalActive` and `matchedCount`, and a specific rate limit. This adds substantial behavioral context about the tool's outputs and constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense yet efficient. Every sentence carries unique information: the main action, default behavior, a conditional invocation, return field semantics, and rate-limit details. There is no redundant phrasing, and the structure flows logically from purpose to details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only, filterable listing tool with four optional parameters, the description covers all essential aspects: what it returns, how filters work, the effect of `includeRestricted`, and rate limiting. The lack of an output schema is compensated by the explicit naming of `totalActive` and `matchedCount`. No critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents all four parameters with descriptions. The tool description adds meaningful context, such as `includeRestricted` bringing in private bundle sales, and clarifies that `totalActive` uses the same denominator as `get_floor_price`. It doesn't fully restate schema details, but enriches the agent's understanding of parameter effects.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Get currently listed CryptoPunks from the native marketplace.' It clearly distinguishes itself from sibling tools by focusing on marketplace listings and by referencing 'same denominator as get_floor_price' to align with that tool's semantics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage context: default behavior includes only publicly buyable listings, how to include restricted ones via `includeRestricted: true`, and optional price-range filtering. It also gives rate limits and shared bucket context. There is no explicit alternative tool discussion, but the instructions are actionable and sufficient for most use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_punk_detailsAGet metadata for specific CryptoPunks: type, traits with rarity percentages, and permalink. Rate limit: 10 per 10 min (read bucket — shared with browse_types, browse_traits, get_listings, get_floor_price, get_bids_for_punk, get_bids_for_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
| punkIds | Yes | Punk IDs to look up (1-100) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true; the description reinforces this by calling it a 'read bucket' and adds a specific rate limit (10 per 10 min) shared with other tools. This adds useful behavioral context beyond the annotation, though it doesn't describe return format or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exactly two sentences: the first explains purpose and outputs, the second provides the rate limit and shared bucket. It is front-loaded, efficient, and contains no unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter, read-only tool, the description covers purpose, outputs, rate limit, and read-only behavior. The schema covers the parameter, and while no output schema exists, the listed output fields (type, traits, permalink) are sufficient. Minor missing details like result ordering do not prevent effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes the single parameter punkIds with min/max constraints and a description ('Punk IDs to look up (1-100)'). The tool description adds no further parameter semantics beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Get') and resource ('metadata for specific CryptoPunks'), listing the exact outputs: type, traits with rarity percentages, and permalink. The use of 'specific' differentiates it from sibling browse tools like browse_types and browse_traits.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'specific CryptoPunks' implies the tool is for fetching details of particular punks, but there is no explicit guidance on when to use this tool versus alternatives, nor any mention of exclusions. The rate limit note lists siblings but does not direct selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
resolve_merkle_rootAReverse-engineer a Merkle root back to its punk IDs and inferred trait selection. ONLY works for roots that already have at least one bid in the CryptoPunks Bids API — this tool looks bids up by root, then derives trait config from the resulting punk set. Returns resolved: false for unknown roots; constructing a root locally and passing it here will not work. Rate limit: 5 per 10 min (compute bucket — shared with filter_punks, compute_merkle_root).
| Name | Required | Description | Default |
|---|---|---|---|
| merkleRoot | Yes | Merkle root to resolve (0x-prefixed, 32 bytes hex) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description discloses critical behavior: it looks up bids by root, derives trait config from the resulting punk set, returns `resolved: false` for unknown roots, and has a rate limit shared with filter_punks and compute_merkle_root. This adds significant transparency beyond the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: four sentences each adding essential information—purpose, prerequisite, return behavior, and rate limit. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description explains the return for unknown roots but does not explicitly detail the full positive response structure. However, it names the key contents (punk IDs and trait selection), which is adequate for a single-parameter resolver. The rate limit and prerequisite are also disclosed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides full parameter coverage (pattern and description for merkleRoot). The description adds semantic constraints: the root must correspond to an existing bid, and locally constructed roots will not work. This provides meaning beyond the schema's format validation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Reverse-engineer a Merkle root back to its punk IDs and inferred trait selection.' This uses a specific verb and resource, and distinguishes it from siblings like compute_merkle_root, which likely does the forward operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use guidance: 'ONLY works for roots that already have at least one bid in the CryptoPunks Bids API' and warns that 'constructing a root locally and passing it here will not work.' This clearly excludes inappropriate use cases and is highly actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Claim this connector by publishing a /.well-known/glama.json file on your server's domain with the following structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"maintainers": [{ "email": "your-email@example.com" }]
}The email address must match the email associated with your Glama account. Once published, Glama will automatically detect and verify the file within a few minutes.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
No comments yet. Be the first to start the discussion!