Cryptominium
Server Details
What a crypto position would really sell for: measured exit costs, address and transaction lookups.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-06-18
- URL
TDQS
Scored across 5 tools
Each tool has a distinct target: exit_cost is per-token sell measurement, exit_index is the market-wide monthly aggregate, explain_transaction reads tx receipts, identify_address resolves addresses/ENS, and search is a router. The only mild overlap is exit_cost vs exit_index (both about exit friction), but the descriptions clearly separate token-level from market-level. An agent should be able to select correctly.
All names are lowercase snake_case, which is consistent formatting. However, the verb pattern is mixed: explain_transaction and identify_address are verb_noun, while exit_cost and exit_index are noun_noun and search is a bare verb. Readable and predictable enough, with only minor deviation.
Five tools is a tight but coherent set for a crypto liquidity/analysis server, with each tool covering a distinct function. It is on the lean side, but nothing feels redundant or padded.
The surface covers the core domain well: exit liquidity per token, market-wide index, transaction decoding, address/ENS identification, and discovery via search. Minor gaps exist (no historical exit data beyond the monthly index, no direct token metadata or price lookup), but the stated purpose is not price feeds and the tools avoid dead ends for the questions they target.
Available Tools
5 toolsexit_costWhat selling a token really returnsARead-onlyIdempotentInspect
Cryptominium measures, every day, what a fixed-size sell of each tracked token actually returns versus its quoted price, by querying live DEX routing on Base, Ethereum and BNB Chain. Use this when someone asks whether a token can really be sold, how liquid it is, or what they would get for a position. Returns the latest measured exit friction (% lost to price impact), the dollars received, the date measured, and a citation — plus, where the token trades on Kraken or Coinbase, what the same sell loses against those order books. Not a price feed and not advice.
| Name | Required | Description | Default |
|---|---|---|---|
| chain | No | Optional: base, ethereum or binance-smart-chain. | |
| token | Yes | Ticker, name or contract address, e.g. "AERO", "pepe", "0x9401…". |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover the safety profile (readOnly, idempotent, non-destructive), so the description's added value is the enumeration of what is returned — exit friction %, dollars received, measurement date, citation, and Kraken/Coinbase order-book comparison. This discloses behavioral traits beyond the annotations, though it omits freshness/refresh cadence for a time-sensitive measurement.
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?
Front-loaded with what is measured and why, then usage, then returns, then boundaries. Three dense sentences that each earn their place, though the enumeration of return fields makes it longer than strictly necessary.
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 carries the return-value burden itself and does so: friction %, dollars received, date, citation, and the Kraken/Coinbase comparison. Nothing an agent needs to call or interpret this tool 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?
Schema coverage is 100%, so the baseline is 3. The description adds meaning by spelling out the supported chains (Base, Ethereum, BNB Chain), which directly informs the optional 'chain' parameter even though the schema does not constrain it with an enum.
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?
States a specific verb+resource ('measures what a fixed-size sell of each tracked token actually returns versus its quoted price') plus the method (live DEX routing on Base, Ethereum, BNB Chain). An agent can distinguish it from exit_index and explain_transaction without opening a schema, and 'Not a price feed' blocks a likely misread.
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?
Explicitly enumerates the trigger questions: 'whether a token can really be sold, how liquid it is, or what they would get for a position,' plus a negative boundary ('not a price feed and not advice'). It never names the closest sibling, exit_index, so the agent must infer which measurement tool applies.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
exit_indexThe monthly Exit-Friction IndexARead-onlyIdempotentInspect
The Cryptominium Exit-Friction Index: each month, the median share of value lost when selling a fixed $100,000 position across every token with a live on-chain market, with quartiles and the share of tokens losing more than half. Use for questions about overall crypto market liquidity or how hard it is to exit altcoins. Optional month as YYYY-MM; defaults to the latest.
| Name | Required | Description | Default |
|---|---|---|---|
| month | No | YYYY-MM, optional. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, openWorld and non-destructive, so safety is covered. The description adds behavior the annotations do not: the month parameter defaults to the latest, and it discloses what the response contains (median, quartiles, >50% loss share).
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, no filler: the first defines the metric and its components, the second gives the usage context and the parameter default. Front-loaded and every clause earns its place.
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 steps in to describe the return contents (median, quartiles, share of tokens losing more than half), and it covers the only parameter's default. An agent has everything needed to call and interpret it.
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 coverage is 100% and the single param is already documented as optional YYYY-MM. The description still adds real meaning by stating the default-to-latest behavior, which the schema does not convey.
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 names the specific statistic and population: the median share of value lost selling a fixed $100,000 position across every token with a live on-chain market, plus quartiles and a tail share. That is far more than a restatement of the name, though it never explicitly distinguishes itself from the sibling exit_cost.
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?
It gives a clear use condition: 'Use for questions about overall crypto market liquidity or how hard it is to exit altcoins.' There is no explicit when-not or routing to exit_cost/other siblings, which keeps it short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
explain_transactionWhat a transaction didARead-onlyIdempotentInspect
Reads an EVM transaction hash on Base, Ethereum or BNB Chain from its receipt logs: whether it succeeded, what moved to and from whom (with token symbols and decimals), what it cost in fees, and any token approvals it granted or revoked, including unlimited ones. The hash is not stored.
| Name | Required | Description | Default |
|---|---|---|---|
| hash | Yes | 0x followed by 64 hex characters. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds real behavioral context beyond them: supported chains (Base, Ethereum, BNB Chain) and the notable state note 'The hash is not stored.'
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?
A single front-loaded sentence that leads with the action and chains the return detail efficiently. It is dense but every clause maps to output content rather than padding.
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 correctly takes on the burden of describing what comes back, and does so thoroughly. The one ambiguity is how the chain is resolved from a hash alone when three chains are supported and no chain parameter exists.
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?
Only one parameter, and the schema already documents the 0x + 64 hex character format at 100% coverage. The description repeats the concept of a hash without adding format, chain-selection, or validation detail, which is the expected baseline when the schema carries the load.
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?
Names a specific verb (reads) and resource (EVM transaction hash receipt logs) and enumerates the concrete outputs: success status, transfers with token symbols/decimals, fees, and approvals including unlimited ones. An agent can tell this apart from identify_address or search without opening the schema.
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?
Usage is implied by the description, but there is no explicit when-to-use or when-not-to-use guidance and no mention of where this sits relative to siblings like search or identify_address. With non-overlapping siblings the risk is low, but the routing rationale is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
identify_addressWhat a crypto address isARead-onlyIdempotentInspect
Identifies a public address or ENS name without being told what it is: wallet or contract, which of seven EVM chains it has been active on (read: Base, Ethereum, BNB Chain; identified: Arbitrum, Polygon, Optimism, Avalanche), EIP-7702 delegation, the token if it is one Cryptominium tracks. Bitcoin addresses are checksum-verified and read; Solana accounts are identified (wallet, mint, token account, program). The address is not stored. A recovery phrase or private key is refused without being looked up.
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes | A public address or ENS name. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnly/openWorld/idempotent annotations, the description adds meaningful behavior: the address is not stored, recovery phrases or private keys are refused without lookup, and it distinguishes 'read' chains from merely 'identified' chains. This is genuine disclosure not present in structured fields.
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?
Front-loaded with the core purpose, then elaborates on chain coverage and safety behavior. Dense but every clause carries information; only the nested parenthetical about chains is slightly heavy.
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 usefully narrates what an agent gets back (address classification, chain activity, delegation, token status, Bitcoin/Solana handling). Complete enough for the call, though return shape details are left implicit.
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 coverage is 100% and the single 'address' parameter is already documented as 'A public address or ENS name.' The description reinforces the input types (Bitcoin, Solana accounts) but adds little syntax or format detail beyond what the schema provides; 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?
States a specific verb (identifies) and resource (a public address or ENS name) and enumerates the exact outputs: wallet vs contract, active chains, EIP-7702 delegation, token identity. It is clearly separable from siblings like explain_transaction and search.
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?
Usage is implied by 'without being told what it is,' which frames the scenario, but no explicit when-to-use vs alternatives or exclusions are given relative to exit_cost, exit_index, explain_transaction, or search. Adequate but leaves routing to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchSearch CryptominiumARead-onlyIdempotentInspect
Cryptominium's crypto search: says what a query is (ticker, address, transaction, comparison, a question about selling a position, a directory category…) and returns the matching coins and Cryptominium pages. Use it to find the right Cryptominium page for a crypto question.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Anything crypto. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds that results are coins and Cryptominium pages (i.e., a discovery/browse surface), which is modest added value, but says nothing about result limits, ranking, or empty-result 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?
Two sentences, front-loaded with the resource and scope. There is mild redundancy between 'returns the matching coins and Cryptominium pages' and 'find the right Cryptominium page', but no filler beyond that.
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, open-world search with no output schema, the description covers input flexibility and the general shape of results. Missing only operational detail (ranking, limits, no-match behavior), which is a minor gap at this 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?
With one parameter and 100% schema coverage, the baseline is 3, but the description goes beyond the schema's terse 'Anything crypto.' by enumerating the query types the parameter accepts (ticker, address, transaction, comparison, question, category), giving the agent concrete guidance on free-text form.
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?
States a specific verb+resource ('crypto search') and enumerates the kinds of input it accepts (ticker, address, transaction, comparison, question, directory category), plus what it returns (matching coins and Cryptominium pages). It does not explicitly name the specialized siblings (identify_address, explain_transaction), but the broad-coverage framing implicitly distinguishes it from them.
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?
'Use it to find the right Cryptominium page for a crypto question' gives a positive usage context, but there is no when-not guidance and no mention of the sibling tools (e.g. using identify_address for a specific address instead). The routing decision is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
- First observed
exit_cost - First observed
exit_index - First observed
explain_transaction - First observed
identify_address - First observed
search
Related MCP Connectors
The on-chain facts you need in the seconds before you transact.
Real-time crypto asset intel for trading AIs: liquidity grades, transfer routes, spreads, BTI
Cryptocurrency fundamentals for agents: TVR Scores, rankings and model-derived valuation estimates.
Crypto portfolio risk analysis: VaR, scenarios, liquidity and correlation engines as MCP tools.
Related MCP Servers
- AlicenseAqualityBmaintenanceUS tax classification for on-chain transactions: tx hash in → canonical category, tax treatment, confidence, and review flags out. 80+ chains.4MIT
- AlicenseNot gradedqualityDmaintenanceMethodology-transparent BTC + ETH whale forensics. 30 tools, anonymous OAuth 2.1 Free tier.MIT
- AlicenseNot gradedqualityBmaintenanceThe verifiable risk engine for autonomous agents: deterministic, self-verifying financial calculations that an agent can delegate and prove. It covers liquidation and funding, position sizing and risk of ruin, options Greeks and margin, LP divergence, treasury concentration and depeg, execution quality checks, plus intelligence on options, DeFi, prediction markets, and transaction safety analysis.14 npm1MIT
- AlicenseAqualityBmaintenanceLocal-first crypto portfolio aggregation across exchanges (Bybit, Binance), EVM and Solana wallets, and Polymarket. Read-only credentials, runs as a local MCP server. Data aggregation only, not financial advice.1567 npm6MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.