Scryfall MCP Server

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes, such as get_card for single cards, search_cards for full-text queries, and csb_find_combos_by_card_ids for combo analysis. However, some overlap exists between search_by_art_tag/search_by_function_tag and search_cards, which could cause minor confusion in tool selection.
Naming Consistency3/5
Naming conventions are mixed, with some tools using verb_noun patterns like get_card or list_sets, while others use descriptive phrases like csb_find_combos_by_card_ids or search_by_art_tag. This inconsistency reduces predictability but remains readable overall.
Tool Count3/5
With 22 tools, the count is borderline high for a Scryfall server, as it includes both core Scryfall operations and Commander Spellbook integration. While comprehensive, it may feel heavy and could benefit from consolidation or clearer scoping.
Completeness5/5
The tool set provides complete coverage for the Scryfall domain, including card retrieval, searching by various criteria, set listing, rulings, and integration with Commander Spellbook for combos. No obvious gaps are present, supporting full agent workflows.
Average 3.2/5 across 22 of 22 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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. It states the tool autocompletes card names, implying a read-only, non-destructive operation, but doesn't cover aspects like rate limits, error handling, response format, or performance characteristics. For a tool with zero annotation coverage, this is inadequate, as it leaves key behavioral traits unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Autocomplete card names based on a partial query.' It is front-loaded with the core purpose, contains no redundant information, and is appropriately sized for the tool's apparent simplicity. Every word earns its place, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations, no output schema, and low schema description coverage, the description is incomplete. It doesn't address what the tool returns, how results are formatted, or any behavioral nuances. For a tool with one parameter but no structured support, the description should provide more context to be fully helpful to an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions 'based on a partial query,' which hints at the 'q' parameter's purpose, but with 0% schema description coverage, it doesn't add meaningful semantics beyond the schema. It fails to explain what constitutes a valid query, expected formats, or examples, leaving the parameter poorly documented. This is below the baseline of 3 due to low coverage without compensation.
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: 'Autocomplete card names based on a partial query.' This specifies the verb ('Autocomplete'), resource ('card names'), and mechanism ('based on a partial query'). However, it doesn't explicitly differentiate from sibling tools like 'search_cards' or 'get_card', which might offer similar functionality, so it doesn't reach the highest 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 any prerequisites, exclusions, or comparisons to sibling tools such as 'search_cards' or 'get_card', leaving the agent with no context for tool selection. This is a significant gap in usage guidance.
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 'Scryfall's powerful full-text syntax' which hints at the search capability, but doesn't describe what the tool returns (e.g., paginated results, error behavior, rate limits, or authentication needs). For a search tool with 8 parameters and no output schema, this leaves significant gaps in understanding how it behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded with the core purpose. Every word earns its place without being overly verbose or under-specified in terms of structure.
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 (8 parameters, low schema coverage of 13%, no annotations, no output schema), the description is incomplete. It doesn't explain what the tool returns, how to handle pagination, error conditions, or the purpose of most parameters. For a search tool with many configuration options, this leaves too much unspecified for effective agent use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 13% (only the 'q' parameter has a description), so the description must compensate but doesn't. It mentions 'Scryfall's powerful full-text syntax' which relates to the 'q' parameter, but doesn't explain the semantics of the other 7 parameters (like 'unique', 'order', 'dir', etc.). The description adds minimal value beyond what little is in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search cards using Scryfall's powerful full-text syntax.' It specifies the verb ('search') and resource ('cards'), and mentions the search engine (Scryfall). However, it doesn't explicitly differentiate this from sibling tools like 'search_by_art_tag' or 'search_by_format', which appear to be more specialized search variants.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With many sibling search tools (e.g., 'search_by_art_tag', 'search_by_format', 'search_by_colors'), there's no indication that this is the general-purpose search tool or when to choose it over more specific ones. The description lacks any 'when' or 'when not' context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states what the tool does, not how it behaves. It doesn't disclose whether this is a read-only operation, what the output format looks like, whether results are paginated, or any rate limits. The mention of 'exact and almost-included' combos adds some behavioral context but is insufficient for a mutation-free tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with zero waste, front-loaded with the core purpose. Every word earns its place by specifying the action, resource, and key behavioral detail ('exact and almost-included').
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 3-parameter tool with no annotations and no output schema, the description is incomplete. It doesn't explain the return format, pagination behavior (implied by limit/offset but not stated), or how 'almost-included' combos are determined. The context signals indicate significant gaps in documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33% (only 'ids' parameter has a description), but the description doesn't compensate by explaining 'limit' or 'offset' parameters. It implies 'ids' are 'Commander Spellbook numeric card IDs' but this is already in the schema. With low coverage and no additional parameter explanation, this meets the baseline for minimal compensation.
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 'Find' and resource 'combos' with the scope 'that the provided cards enable', specifying both 'exact and almost-included' combos. It distinguishes from sibling 'csb_find_combos_by_names' by using card IDs instead of names, but doesn't explicitly differentiate from other combo-finding tools like 'csb_variants_search'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'csb_find_combos_by_names' or 'csb_variants_search'. The description implies usage with numeric card IDs but doesn't specify prerequisites (e.g., needing Commander Spellbook IDs) or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states the search action without disclosing behavioral traits. It doesn't mention whether this is a read-only operation, potential rate limits, authentication needs, pagination behavior (implied by limit/offset but not explained), or what the output looks like. For a search tool with 5 parameters and no annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Search Commander Spellbook variants (combos)') and includes key filtering information. There is zero wasted text, making it appropriately concise for a search tool.
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 (5 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain the return format, pagination behavior (despite limit/offset parameters), error conditions, or how it differs from similar sibling tools. For a search operation with multiple filters and no structured output documentation, more context is needed.
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 mentions 'filters like uses/produces', which adds context for two of the five parameters (uses, produces). With 60% schema description coverage, the schema documents all parameters but only three have descriptions (uses, produces, of). The description provides minimal additional meaning beyond the schema, compensating slightly but not fully for the coverage gap.
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 'Search' and resource 'Commander Spellbook variants (combos)', making the purpose understandable. It distinguishes from some siblings like 'csb_card' or 'get_card' by focusing on variants/combos rather than individual cards. However, it doesn't explicitly differentiate from 'csb_find_combos_by_card_ids' or 'csb_find_combos_by_names' which also search combos.
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 mentions filtering by 'uses/produces', which implies usage for filtered searches, but provides no explicit guidance on when to use this tool versus alternatives like 'csb_find_combos_by_card_ids' or 'csb_find_combos_by_names'. There are no prerequisites, exclusions, or comparisons to sibling tools stated.
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 action ('Get official rulings') but does not describe traits such as whether it's read-only, requires authentication, has rate limits, or what the return format looks like. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence earns its place by specifying the action, resource, and method concisely.
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 (a read operation with one parameter), no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, return values, or error handling. For a tool with minimal structured data, the description should provide more context to be fully helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one parameter ('id') with 0% description coverage, and the description adds meaning by specifying it as a 'Scryfall UUID'. This clarifies the parameter's purpose beyond the schema's format hint. However, it does not provide additional details like examples or constraints, so it partially compensates for the low schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get official rulings for a card by Scryfall UUID.' It specifies the verb ('Get'), resource ('official rulings for a card'), and method ('by Scryfall UUID'). However, it does not explicitly differentiate from sibling tools like 'get_card' or 'csb_card', which might retrieve card data rather than rulings.
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 the method ('by Scryfall UUID') but does not specify prerequisites, exclusions, or compare it to sibling tools like 'search_cards' or 'get_card' that might also relate to card information. Usage is implied but not explicitly defined.
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 'Fetch' but doesn't clarify if this is a read-only operation, requires authentication, has rate limits, or what the return format looks like. 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the essential information without any wasted words. It directly states the tool's purpose, making it highly concise and well-structured for quick understanding.
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 lack of annotations and output schema, the description is incomplete for a tool that likely returns complex card data. It doesn't explain what 'card' entails (e.g., fields like name, text, rulings) or error handling, leaving the agent unprepared for effective use in a broader context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaningful context beyond the input schema by specifying that the 'id' parameter is a 'numeric ID' for a 'Commander Spellbook card'. With 0% schema description coverage and only one parameter, this adequately compensates, though it could detail format constraints like ID ranges or examples.
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 ('Fetch') and resource ('Commander Spellbook card by numeric ID'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_card' or 'csb_read_card_index', which likely serve similar purposes, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With many sibling tools like 'get_card', 'search_cards', and 'csb_read_card_index', there's no indication of prerequisites, constraints, or comparative use cases, leaving the agent to guess based on tool names 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. It mentions parsing into cards but doesn't disclose behavioral traits such as error handling (e.g., invalid text formats), performance (e.g., rate limits or processing time), or output specifics (though an output schema exists). For a tool with no annotation coverage, this is a significant gap in transparency about 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 a single, efficient sentence that front-loads the core action ('parse a plain-text decklist') and context ('using Commander Spellbook'). Every word earns its place with no redundancy or unnecessary details, making it highly concise and well-structured 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 one parameter with full schema coverage and an output schema, the description is minimally complete. It states the purpose but lacks context on usage guidelines, behavioral transparency, and integration with siblings. For a tool in a complex server with many siblings, more guidance would be helpful, but the structured data (schema, output schema) covers basic needs adequately.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the parameter 'text' fully documented in the schema. The description adds minimal value by specifying 'plain-text deck list, e.g., '1x Sol Ring' per line', which reinforces the schema but doesn't provide additional semantics like format constraints or examples beyond what's already covered. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('parse') and resource ('plain-text decklist into cards'), specifying the target system ('using Commander Spellbook'). It distinguishes from siblings like 'csb_build_card_index' or 'csb_card' by focusing on text parsing rather than indexing or individual card lookup. However, it doesn't explicitly contrast with 'search_cards' or 'autocomplete', which might also handle text input, leaving minor ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives is provided. The description implies usage for parsing deck lists, but it doesn't specify scenarios like converting user input for combo analysis (vs. 'csb_find_combos_by_names') or handling raw text vs. structured queries (vs. 'search_cards'). This lack of context leaves the agent to infer usage based on tool names 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. It states the tool retrieves a single card but doesn't mention error handling (e.g., what happens if no card is found), performance characteristics, rate limits, or authentication requirements. For a read operation with no annotation coverage, this leaves significant gaps in understanding the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that efficiently conveys the core functionality. It's front-loaded with the main purpose and includes essential details about lookup methods without unnecessary elaboration. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (3 parameters, no annotations, no output schema), the description is minimally adequate. It covers the basic purpose and parameter relationships but lacks details on error cases, return format, or usage context. For a tool that likely interacts with a card database, more behavioral context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 33% (only the 'fuzzy' parameter has a description). The description adds value by explaining that 'name' supports both exact and fuzzy matching, which clarifies the relationship between the 'name' and 'fuzzy' parameters. However, it doesn't explain the 'id' parameter's UUID format or provide examples of name matching, leaving some semantic gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get a single card by Scryfall UUID or by name (exact/fuzzy).' It specifies the verb ('Get'), resource ('a single card'), and two lookup methods (UUID or name matching). However, it doesn't explicitly differentiate from sibling tools like 'csb_card' or 'search_cards' which might have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It mentions two lookup methods but doesn't indicate which to prefer, when fuzzy matching is appropriate, or how this differs from sibling tools like 'csb_card' or 'search_cards' that might retrieve cards differently.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. The description only states what the tool does ('Find cards') but doesn't disclose any behavioral traits: no information about pagination behavior (despite a 'page' parameter), rate limits, authentication requirements, response format, or whether this is a read-only operation. For a search tool with 5 parameters and no annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise (one sentence with examples) and front-loaded with the core purpose. Every word earns its place, with no redundant information. The examples ('squirrel, dragon, wizard') efficiently illustrate the concept without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, 0% schema description coverage, no annotations, but has an output schema, the description is minimally adequate. The output schema reduces the need to describe return values, but the description fails to address key contextual aspects: no guidance on when to use versus sibling tools, incomplete parameter semantics, and missing behavioral transparency. For a search tool in a crowded namespace, this leaves significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the schema provides no parameter documentation. The description only mentions 'tags' with examples, ignoring the other 4 parameters (match, colors, type, page). While it clarifies that tags refer to 'Tagger artwork tags,' it doesn't explain parameter relationships, default values, or the meaning of 'match' enum options. The description adds minimal value beyond what's implied by the tool name.
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: 'Find cards using Tagger artwork tags' with specific examples like 'squirrel, dragon, wizard.' This is a clear verb+resource combination that distinguishes it from general card search tools. However, it doesn't explicitly differentiate from sibling tools like 'search_by_function_tag' or 'search_cards' beyond mentioning 'artwork tags.'
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With many sibling search tools available (search_by_cmc, search_by_colors, search_by_format, search_by_function_tag, search_cards), the description fails to indicate when this specific art tag search is appropriate versus other search methods. No exclusions or prerequisites are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions filtering options but does not describe key behaviors like pagination (implied by the 'page' parameter in the schema), rate limits, authentication needs, or what the output contains. For a search tool with no 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 a single, efficient sentence: 'Find cards within a mana value range, optionally filtered by color and type.' It is front-loaded with the core purpose and includes optional filters without unnecessary detail, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (5 parameters, no annotations, but with an output schema), the description is incomplete. It covers the basic purpose but lacks usage guidelines, behavioral details, and full parameter explanations. The presence of an output schema reduces the need to describe return values, but the description should still address when to use this tool and its operational constraints.
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 minimal semantics beyond the input schema. It mentions 'mana value range' (mapping to 'min' and 'max'), 'color' (mapping to 'colors'), and 'type' (mapping to 'type'), but does not explain the format of 'type' or the meaning of 'page'. With 0% schema description coverage, the description partially compensates but leaves key parameters like 'page' and the enum values for 'colors' undocumented.
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: 'Find cards within a mana value range, optionally filtered by color and type.' It specifies the verb ('Find'), resource ('cards'), and scope ('mana value range'), but does not explicitly differentiate from sibling tools like 'search_by_colors' or 'search_cards', which appear to offer overlapping functionality. This makes it clear but not fully distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With sibling tools such as 'search_by_colors', 'search_by_format', and 'search_cards', there is no indication of when this specific mana-value-based search is preferred or what its limitations are. This leaves the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't describe how it behaves: no information about pagination (implied by 'page' parameter), rate limits, authentication needs, error conditions, or what the output contains. This is inadequate for a search tool with 5 parameters.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a search tool and front-loads the core functionality.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 5 parameters, no annotations, and an output schema exists (which reduces the need to describe return values), the description is minimally complete. It states what the tool does but lacks behavioral context and parameter guidance that would help an agent use it effectively. The existence of an output schema prevents a lower score.
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 mentions 'colors or color identity' which hints at the 'colors' and 'identity' parameters, but with only 40% schema description coverage, it doesn't explain the 'mode', 'include_colorless', or 'page' parameters. The description adds minimal value beyond what the schema's enum values and descriptions already provide for some parameters.
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 'Find' and resource 'cards' with the specific criteria 'by colors or color identity', making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'search_cards' or 'search_by_format', which likely also search cards with different filters.
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 'search_cards' or 'search_by_format'. It doesn't mention prerequisites, exclusions, or comparative use cases, leaving the agent to guess based on tool names 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. It states the tool 'finds' cards, implying a read-only operation, but doesn't clarify aspects like pagination behavior (hinted by the 'page' parameter), rate limits, authentication needs, or what the output contains. For a search tool with 4 parameters and no annotation coverage, this leaves significant gaps in understanding how the tool behaves.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence: 'Find cards by legality in a given format.' It is front-loaded with the core purpose and contains no unnecessary words. Every part of the sentence contributes directly to understanding the tool's function.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (4 parameters, no annotations, but with an output schema), the description is minimally adequate. It states the purpose but lacks details on usage guidelines, behavioral traits, and parameter meanings. The presence of an output schema means return values are documented elsewhere, so the description doesn't need to explain them. However, for a search tool with multiple filtering options, more context would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions 'legality in a given format,' which aligns with the 'format' and 'status' parameters, but doesn't explain the meaning of 'colors' or 'page.' With 0% schema description coverage, the schema provides no parameter descriptions, so the description adds some value by hinting at the primary use case. However, it doesn't fully compensate for the lack of details on all parameters, resulting in a baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Find cards by legality in a given format.' It specifies the verb ('Find') and resource ('cards'), and indicates the primary filtering criterion ('by legality in a given format'). However, it doesn't explicitly differentiate from sibling tools like 'search_cards' or 'search_by_colors', which reduces the score from 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. It doesn't mention sibling tools like 'search_cards' (which might be more general) or 'search_by_colors' (which filters by a different criterion), nor does it specify prerequisites or exclusions. The user must infer usage from the tool name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the search mechanism but doesn't cover critical aspects like pagination behavior (implied by the 'page' parameter), rate limits, authentication needs, or what the output contains. The description is minimal and leaves key behavioral traits unspecified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place, with no wasted text, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (5 parameters, 0% schema coverage, no annotations) and the presence of an output schema, the description is incomplete. It lacks details on parameter usage, behavioral context, and how results are returned, though the output schema mitigates some gaps by documenting return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It only hints at the 'tags' parameter with examples ('removal, ramp'), but doesn't explain other parameters like 'match', 'colors', 'format', or 'page'. The description adds minimal value beyond the schema, failing to fully address the coverage gap.
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 ('Find cards') and the mechanism ('using Tagger function (oracle) tags'), with specific examples ('e.g. removal, ramp'). It distinguishes itself from generic search tools by focusing on function tags, though it doesn't explicitly differentiate from sibling 'search_by_art_tag' or 'search_by_format'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'search_by_colors', 'search_by_format', or 'search_cards'. The description implies usage for function-based searches but lacks explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Rebuild' and 'write cache', implying a mutation operation that could be resource-intensive or require specific permissions, but doesn't detail potential side effects, performance impact, or error conditions. This is insufficient for a tool that likely modifies data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise—a single sentence that directly states the tool's action and outcome without any fluff. It's front-loaded and wastes no words, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is minimally complete. However, as a mutation tool with no annotations, it should ideally explain more about the rebuild process, cache implications, or when it's safe to use. The output schema helps, but behavioral aspects are under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate here, but it could briefly note the lack of inputs for clarity. A baseline of 4 is given as it meets minimal requirements without gaps.
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 ('Rebuild') and the resource ('oracleId→CSB id index and write cache'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'csb_read_card_index' or 'read_tagger_cache', which might involve similar index/cache operations, leaving some ambiguity about uniqueness.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this should be run periodically, after data updates, or as a maintenance task compared to read-only siblings like 'csb_read_card_index'. This lack of context makes it hard for an agent to decide when to invoke it.
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 it reads from a 'local cache', implying it's a read-only operation, but doesn't specify performance characteristics, cache freshness, error handling, or what happens if the cache is empty. This is a significant gap 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 a single, efficient sentence that directly states the tool's function without any fluff. It's front-loaded and wastes no words, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is minimally complete. However, it lacks behavioral details (e.g., cache behavior, output format hints) that could enhance agent understanding, especially with no annotations, making it adequate but with 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 tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description doesn't add param info, but that's appropriate here, earning a baseline score of 4 for adequately handling the lack of parameters.
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 ('Read') and the resource ('oracleId→CSB id index from local cache'), making the purpose understandable. However, it doesn't explicitly differentiate this from sibling tools like 'csb_lookup_by_oracle_ids' or 'read_tagger_cache', which might involve similar cache operations, 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 doesn't mention prerequisites, context, or exclusions, leaving the agent with no usage direction beyond the basic purpose.
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 all sets, but does not mention any behavioral traits such as pagination, rate limits, authentication needs, or what the output format might be. This is a significant gap 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 a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks completeness. It does not explain return values or behavioral aspects, which could be important for an agent to use it correctly. However, for a basic list operation, it meets the minimum viable threshold.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description does not add parameter details, which is appropriate here, and it implies no parameters are required, aligning with the schema. Baseline is 4 for 0 parameters.
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 ('List') and the resource ('all sets available on Scryfall'), providing a specific verb+resource combination. However, it does not differentiate from sibling tools like 'search_by_format' or 'search_cards' which might also return set-related information, so it doesn't fully distinguish from alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'search_by_format' or 'search_cards'. It lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions fetching from a 'public docs page', implying a read-only, external API call, but doesn't disclose behavioral traits like rate limits, network dependencies, error handling, or response format. For a tool with zero annotation coverage, this leaves significant gaps in understanding its operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It front-loads the key action and resource, making it easy to scan. Every word earns its place, providing essential context without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no annotations) and the presence of an output schema (which handles return values), the description is minimally adequate. It states what the tool does but lacks details on behavior, usage context, or integration with siblings. For a simple fetch tool, it meets basic needs but could be more informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter information, which is appropriate. Baseline is 4 for zero parameters, as it doesn't need to compensate for any schema gaps.
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 ('fetches') and resource ('Scryfall Tagger tag names'), with specific source ('public docs page'). It distinguishes from siblings like 'refresh_tagger_tags' (which likely updates) and 'read_tagger_cache' (which reads cached data), though not explicitly named. Purpose is specific but could be more precise about differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives is provided. It doesn't mention when to choose this over 'refresh_tagger_tags' (for updating tags) or 'read_tagger_cache' (for cached data), nor does it specify prerequisites like needing internet access. Usage is implied only by the action 'fetches', with no explicit context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions fetching a random card with optional search filtering, but fails to describe key behaviors such as how randomness is determined, whether results are paginated or single, error handling, or any rate limits. This leaves significant gaps in understanding the tool's operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('fetch a random card') and adds necessary detail about the optional filter. There is no wasted language, making it highly concise and well-structured for quick comprehension.
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 a random fetch operation with filtering, no annotations, and no output schema, the description is incomplete. It doesn't explain what a 'card' entails in this context, the return format, or how the randomness interacts with the query, making it inadequate for full understanding without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 0% description coverage, so the description must compensate. It adds meaning by explaining that 'q' is an optional search query for filtering, which clarifies its purpose beyond the schema. However, it doesn't detail the query format, syntax, or examples, leaving some ambiguity.
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 ('fetch') and resource ('a random card'), making the purpose immediately understandable. It distinguishes itself from most siblings by focusing on randomness rather than specific lookup or search operations, though it doesn't explicitly contrast with tools like 'get_card' or 'search_cards'.
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 through the phrase 'optionally filtered by a 'q' search query,' suggesting this tool is for obtaining random cards with possible filtering. However, it lacks explicit guidance on when to use this versus alternatives like 'get_card' for specific cards or 'search_cards' for broader searches, leaving the context somewhat vague.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states 'Force refresh' and 'write local cache', implying a write/mutation operation, but doesn't disclose behavioral traits like required permissions, side effects (e.g., overwriting cache), rate limits, or what 'Force' entails (e.g., ignoring timestamps).
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?
Single sentence, front-loaded with key action ('Force refresh'), zero waste. Every word earns its place by specifying source ('from docs') and destination ('write local cache').
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 0 parameters, 100% schema coverage, and an output schema (which handles return values), the description is minimally complete. However, as a mutation tool with no annotations, it lacks details on permissions, side effects, or error conditions, leaving gaps for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema coverage, so no parameter documentation is needed. The description adds no parameter info, which is appropriate, earning a baseline 4 for not missing anything.
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 ('Force refresh') and resource ('Tagger tags from docs'), specifying it writes to a local cache. It distinguishes from sibling 'list_tagger_tags' (which likely reads) and 'read_tagger_cache' (which reads cache), but doesn't explicitly name these alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like 'list_tagger_tags' or 'read_tagger_cache'. The description implies it's for updating cached tags, but lacks explicit when/when-not instructions or prerequisites (e.g., after docs change).
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 multi-step process (Scryfall resolution, cached index mapping, calling find-my-combos), which adds useful context beyond basic functionality. However, it doesn't cover critical behavioral traits like error handling, performance characteristics, rate limits, or what 'find-my-combos' entails in terms of output format or limitations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise and front-loaded, using a single sentence that efficiently outlines the entire process. Every word earns its place, with no redundant information or fluff. It's appropriately sized for the tool's complexity, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (multi-step process with 4 parameters), no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., combo details, error formats), how to interpret results, or handle edge cases. For a tool that involves external API calls (Scryfall) and internal mapping, more contextual information is needed to guide effective usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low at 25%, with only the 'fuzzy' parameter documented. The description doesn't add any parameter-specific semantics beyond what's implied by the tool name (e.g., 'names' parameter is for card names). It doesn't explain the purpose of 'limit' or 'offset', or provide usage examples. Given the low coverage, the description fails to compensate adequately, resulting in a baseline score.
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: it resolves card names to IDs and finds combos. It specifies the verb 'find combos' and the resource 'by card names', distinguishing it from siblings like csb_find_combos_by_card_ids. However, it doesn't explicitly contrast with other search tools (e.g., search_by_function_tag), leaving some ambiguity in sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when you have card names and want to find combos, but it doesn't provide explicit guidance on when to use this versus alternatives like csb_find_combos_by_card_ids or other search tools. It mentions the process (resolve names, map IDs, call find-my-combos), which gives some context, but lacks clear when/when-not instructions or named alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals two important behavioral traits: it uses a 'local index' (implying cached data) and 'builds if stale' (indicating automatic index maintenance). This provides useful context about performance and data freshness that isn't obvious from the schema alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that packs essential information: the mapping operation, input/output types, and behavioral context about the local index. Every word earns its place with no redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (mapping operation with automatic index building), no annotations, but with an output schema, the description provides good coverage. It explains the core functionality and key behavioral aspects, though additional details about error cases or performance characteristics could enhance completeness.
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 schema description coverage is 0%, but the description adds meaningful context about the parameter: it explains that 'oracleIds' are 'Scryfall oracle_id UUIDs' and that they get mapped to 'Commander Spellbook numeric IDs'. This provides semantic value beyond the bare schema, though it doesn't detail format constraints or usage examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Map'), the input resource ('Scryfall oracle_id UUIDs'), and the output resource ('Commander Spellbook numeric IDs'). It distinguishes from siblings by specifying the mapping functionality rather than searching, building, or other operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: when you have Scryfall oracle IDs and need to map them to Commander Spellbook IDs. It doesn't explicitly mention when not to use it or name specific alternatives, but the context is sufficient for basic 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?
No annotations are provided, so the description carries the full burden. It discloses key behavioral traits: it's a read operation (implied by 'Read') and operates locally without network access. However, it lacks details on error handling, file location, cache freshness, or output format, leaving gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose ('Read tags from local cache file') and adds critical context ('without network'). Every word earns its place, with no redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (0 parameters, no annotations, but with an output schema), the description is reasonably complete. It covers the what and how, but since an output schema exists, it doesn't need to explain return values. However, it could benefit from mentioning potential limitations (e.g., cache staleness) for full 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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by clarifying the tool's scope ('local cache file'), which isn't captured in the schema. A baseline of 4 is appropriate for zero-parameter tools with high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Read tags') and resource ('from local cache file'), with explicit differentiation from network-based operations ('without network'). This distinguishes it from sibling tools like 'refresh_tagger_tags' or 'list_tagger_tags' that likely involve network calls or broader operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage ('without network'), implying this tool should be used when offline or for faster local access. However, it does not explicitly state when not to use it or name specific alternatives (e.g., 'list_tagger_tags' for network-based tag retrieval), which prevents a perfect score.
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:

[![scryfall-connector MCP server](https://glama.ai/mcp/servers/latte-chan/scryfall-connector/badges/card.svg)](https://glama.ai/mcp/servers/latte-chan/scryfall-connector)

Score Badge

Copy to your README.md:

[![scryfall-connector MCP server](https://glama.ai/mcp/servers/latte-chan/scryfall-connector/badges/score.svg)](https://glama.ai/mcp/servers/latte-chan/scryfall-connector)

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/latte-chan/scryfall-connector'

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