mcp

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden. It usefully discloses output structure ('one row per venue in coverage-matrix order', explicitly no ranking or sort), but says nothing about auth, rate limits, error behavior, or what a row's credit-cost value represents.

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 tight sentences plus a pointer: the purpose question is front-loaded, then the output-ordering caveat. Every clause earns its place, though the trailing guide reference and quoted 'best' are slightly loose.

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 six-parameter tool with no output schema and no annotations, the description needs to do more. It covers row granularity and ordering but omits what fields a row contains, the units of the cost, and any prerequisite context, leaving the agent partly guessing about the return.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, including enum explanations for side, class, and collateral, so the schema already documents all six parameters thoroughly. The description adds only a restatement of tenor and LTV, earning the baseline 3.

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 opening question states a specific comparison: credit cost at a given tenor and LTV across every covered venue. It clearly frames the tool as a cross-venue comparison rather than a single-venue lookup (contrast with get_venue), though it names no sibling explicitly.

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 question framing and the note that there is 'no ranking, no default sort, no best', which signals this is not a ranking tool. It also routes to 'get_guide with question: SQ-C2' for standard questions, but gives no explicit when-not or named alternatives among the many siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does so unusually well: it discloses the counting rule (a coin counted once, at its owner), the custodian subtraction rule, that pledged/wrapped/lent-out is never added into totals, that nothing is ranked, that absences are shown with a reason rather than zero, and that a quarter's sheet is fixed once filings are in. It gives a genuine grade taxonomy (A–D) so the agent knows how to read confidence. Only auth/rate-limit behavior is unstated, which is minor for a read tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The first sentence front-loads the core, and most clauses carry real information. But it is a single dense paragraph built on long semicolon chains, which taxes parsing, and the closing 'Returns the route's payload as served' is vague filler. For a two-parameter read tool the volume is heavier than needed to be actionable.

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?

There is no output schema and no annotations, so the description must define the return content, and it does: one line per holder with figure, date, source and grade, three stated totals, and a remainder described by coin age and address size. Response envelope details (pagination, error behavior) and the meaning of 'the route's payload as served' remain unstated, keeping it short of complete.

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 both params are already documented, so the baseline is 3. The description goes beyond the schema by explaining that as_of defaults to the latest, that quarter resolves to that quarter's last day, and that a quarter's value is frozen once filings arrive — semantics the schema does not convey. It does not state what happens if both are supplied, so it stops short of a 5.

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 concretely defines the resource: a per-holder ledger of mined bitcoin with pledged/wrapped/lent-out as a separate view. It implicitly differentiates from siblings like get_fund_holdings by stating that fund shares held for a victim are 'listed, not added' and coins are counted once at the owner. It loses a point because the operative verb is only stated at the very end ('Returns the route's payload as served') and the opening sentence leads with domain semantics rather than the action.

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 real selection guidance between the two parameters (as_of for a written date, quarter for a quarter's last day), which is usage-relevant. However, it never says when to reach for this tool versus adjacent analytical siblings such as get_fund_holdings, get_market_composition, or get_cost_basis, and it states no exclusions or prerequisites. Usage is implied rather than instructed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations to lean on, the description carries the full burden and does so: vintage retention, day-granularity back to 2009, UTC end-of-day semantics for as_known_on, the pricing methodology behind priced values, the extra response fields (coingecko_share, price_today), and the attribution obligation in the licence block. It also sets scope ('returns data; it does not advise, forecast, or characterise the market').

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 verb and resource, then value-adding detail in two short paragraphs. The pricing methodology block is dense but relevant to interpreting output; the closing scope sentence is slightly boilerplate but cheap.

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?

There is no output schema, and the description compensates by enumerating what comes back (values with date and kind, unit, source, limitation, vintages, licence block). For a 4-param read tool with vintage semantics, nothing needed to call and interpret it 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 baseline is 3, but the description adds value beyond the schema by explaining what as_known_on means in practice (reproduce a past answer as the store held it at end of day UTC) and by tying id values to list_chain_series. from/to semantics are only implied by the day-granular/back-to-2009 note.

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 ('Returns one series') plus the resource, its scope ('by id'), and explicitly routes id discovery to the sibling list_chain_series. An agent can separate this retrieval tool from the listing tools 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?

Gives a clear condition for the distinctive parameter: use as_known_on when a past answer must be reproduced, which implicitly contrasts with omitting it for current data. It points to list_chain_series for valid ids, but does not address overlap with get_series or get_indicator, so no explicit exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does substantial work: it discloses rendering rules (one unit per panel, rate axes from zero, absent series as a gap not a zero, coverage steps), the refusal path with the plan's reasons, and the exact return contract (embedded image/svg+xml resource plus a public serving URL). It does not mention permissions, rate limits or idempotency, but for a read-only generation tool the disclosure is unusually rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The content is dense but almost every clause earns its place — drawing rules, refusal behavior and return shape are all decision-relevant. The execution is heavier than ideal: the first sentence is a long colon-and-semicolon run-on, which slows parsing even though nothing is truly wasted.

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 7-parameter tool with no output schema and no annotations, the description covers the input contract, the rendering semantics, the refusal case and the return type (SVG resource + URL), which is what an agent needs to call and consume it correctly. Only secondary operational details (auth, limits, error forms) are absent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3; the description mostly restates the schema's own parameter text ('site' default vs 'post', log axis, title heading). It adds only marginal nuance such as 'where the plan offers one' for the log axis and the get_series window/as_known_on equivalence, so it does not clearly exceed the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Opens with a specific verb and product ('Draws the series get_series would return ... as an SVG image in the Stack's house style') and explicitly anchors its input source in list_series, so it is immediately distinguishable from the data siblings. It also closes the loop on scope by stating what it does not do ('draws data; it does not advise, forecast or characterise the market').

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 tells the agent where the ids come from (list_series) and that the request semantics mirror get_series, which effectively routes between this tool and its nearest alternative. It lacks an explicit when-not rule (e.g. 'for raw values use get_series'), but the data-vs-draw distinction and the refusal condition give clear context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and discloses key behavioral nuances: btc_holdings_derived is display-only and never in backing_ratio, the bitcoin-pledged debt attribution convention is stated as a convention rather than a measurement, and income returns reflect accrual not payment. It does not mention safety or read-only status, but it thoroughly explains data semantics and edge-case handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core purpose is front-loaded in the first sentence, but the description runs to multiple dense paragraphs with parenthetical asides and conventions. While the information is relevant, it is longer than needed for a single-parameter list tool and could be trimmed without losing critical guidance.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the absence of annotations and an output schema, the description is thorough: it covers the return shape, pricing source (IEX), attribution conventions, and what happens with and without the 'issuer' parameter. Nothing essential for correct invocation appears 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 explaining the behavioral difference between omitting 'issuer' (all instruments, summarised attribution) and supplying it (that company's instruments with full debt-line detail). This goes beyond the schema's terse field description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: 'Lists the instruments of the corporate issuers in the registry (convertible notes, credit facilities, bonds, perpetual preferreds), one row per instrument,' and distinguishes the scope from bitcoin-backed credit. It names the sibling concept it is not ('Corporate lending, not bitcoin-backed credit'), so an agent can separate it from credit-state or debt-collateral tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description defines the effect of the optional 'issuer' parameter and points to a guide question (SQ-Co1), but it never names an alternative tool or states when not to use this one. The contrast with bitcoin-backed credit is a helpful scoping hint, yet no explicit routing such as 'for bitcoin-backed credit use X' is given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so well: it discloses data provenance, bucket construction, legacy-price treatment, pre-2010 handling, return shape, licence attribution, and the non-advisory nature of the tool. These are substantive behavioral and limitation details rather than restatements of the schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded and the description is information-dense. It is somewhat long, but nearly every sentence adds relevant behavioral or data-interpretation context.

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?

There is no output schema, but the description explicitly lists the returned object fields and key limitations. Combined with complete parameter coverage, it gives an agent enough context to invoke and interpret the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters. The description adds useful context about logarithmic price buckets and the default 1.02 ratio spanning 2%, but it does not materially extend per-parameter semantics beyond what the schema provides.

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 states a specific verb and resource: returns Bitcoin supply alive at the end of a UTC day, grouped by creation-price buckets. It is clear what the tool computes, but it does not explicitly distinguish itself from nearby siblings such as get_series or get_indicator.

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 through the reference to standard questions and get_guide SQ-Ch4, and the day-granular scope is clear. However, there is no explicit when-to-use/when-not-to-use guidance or named alternative sibling tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the burden. It discloses real behavioral traits: the coverage-gap semantics ('a declared gap, not a zero'), that rows from missing venues are counted as unavailable, and that the history field is omitted unless requested. It stops short of stating freshness/rate-limit or return shape, which is acceptable since no output schema exists but pagination is irrelevant here.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The content is valuable but the prose is dense and meandering, with rhetorical framing ('What does ... cost?') and a long parenthetical about corporate debt attribution that could be trimmed. Front-loading the coverage warning early would help an agent more than the question-style opener.

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?

Composite analytical reading with no output schema and no annotations, so the description must explain what comes back: term structure, outstanding quantity, valuation, collateral mix, quality composition, and the coverage block. It does explain the output shape, but the concise structure loses some clarity on what 'the same six figures at market and class level' means for the eth variant.

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 both parameters are already documented. The description adds the 'never added to bitcoin' and 'ether lent against ether is its own book, outside the headline' nuance, but the core enum semantics duplicate the schema. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific analytical purpose: aggregated bitcoin-collateralised credit cost and outstanding quantity across a venue universe. It clearly distinguishes this from per-venue readings ('not any single venue's book') and from get_corporate_instruments. The verb+resource framing is more analytical than a clean 'get X' but the scope is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly routes corporate-issuer debt to get_corporate_instruments and explains the collateral: 'eth' variant as a separate reading never added to bitcoin. The gap is that it does not contrast with get_credit_state_history or compare_venues, siblings that an agent may easily confuse with this one.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does so well: it warns that coverage is not constant and that a move may be a venue entering/leaving observation rather than a market move, states that missing pooled-venue readings are 'an absence with its reason, never a zero', notes monthly debt reads, and says the answer's steps/notes mark coverage changes. It also pre-empts misinterpretation ('it does not forecast and it does not characterise a trend').

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose leads and the critical coverage caveat is surfaced early with a clear warning glyph, so the reader hits the important constraints first. It is somewhat long and repeats the collateral wording verbatim from the schema, which is wasted space.

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 two-parameter read tool with no annotations and no output schema, the description supplies what an agent needs: what the series is, what each point carries (coverage), how missing data appears, and where the answer documents coverage changes. Nothing essential to calling or interpreting the 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 does expand on the ether semantics (ether, staking and restaking tokens at their own contract rates, 'never added to bitcoin'), but that text is repeated almost verbatim from the schema's collateral description, and the 'days' parameter (default 365, cap 3650) is not mentioned at all in the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource ('the same cross-venue reading as get_credit_state, as a daily series') and explicitly anchors the tool against sibling get_credit_state, so an agent can distinguish history-of-state from current-state without opening either schema. The framing question plus the 'as a daily series' qualifier nails the scope.

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 clearly signals when to reach for this tool by naming the sibling (get_credit_state) whose output it extends over time, and gives the selecting condition for the collateral alternative ('Bitcoin by default; pass collateral: "eth" for credit secured by ether'). It stops short of stating exclusions or naming tools that are better for other credit questions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It discloses the returned content categories (collateral, venue type, named observers, collateral rule) and the windowing behavior of days, but does not state read-only status, authentication needs, rate limits, pagination, or return format.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The core purpose is front-loaded, but the description is a long, somewhat run-on sentence with awkward punctuation, a stray apostrophe, and references to the site panel and guide that could be tightened. It is adequate but not cleanly structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description does a fair job explaining what the tool returns, including observer names, collateral rules, and corporate class totals. It leaves some behavioral gaps, but for a one-parameter read tool it is largely complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is already 100%, so the schema documents the single days parameter. The description adds only that days sets the window of the series it carries, which is a minor restatement rather than new syntax or behavior beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific resource and scope: what backs dollar debt against bitcoin, broken down by collateral and venue type, and mentions the site panel it mirrors. It also distinguishes the corporate class totals from per-company rows handled by get_corporate_instruments, which helps separate it from a sibling.

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 explicitly ties itself to standard question SQ-M5 and directs the agent to get_guide with that question. It also names get_corporate_instruments as the alternative for per-company rows, giving a concrete routing condition, though it lacks broader when-not guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does add real context: rates are administered rather than market-cleared, stale cards are marked, and the payload is returned as served. It stops short of auth needs, rate limits, or freshness thresholds, but the non-obvious semantics are disclosed.

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 return shape before any caveats, and every sentence contributes (fields, semantics, staleness, filter, routing hint). The long first sentence is dense but not padded.

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?

No output schema exists, so the description appropriately enumerates the returned columns and the payload's pass-through nature. For a single optional-parameter read tool, that is nearly sufficient; only error/empty-result behavior is 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 optional parameter is already documented in the schema with examples. The description only restates the filter behavior ('Pass desk to read one desk's cards'), adding no syntax or format detail beyond the schema; 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?

Names a specific resource (posted rate cards from custodial lending desks) and enumerates the returned fields (APR range, term, max LTV, custody/liquidation model, effective date, source), which is enough to distinguish it from siblings like compare_venues or get_venue. An agent can tell what this returns without opening any 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?

It states 'Pass desk to read one desk's cards,' which implies the filtering behavior, but never says when to prefer this over alternatives such as compare_venues or get_venue, nor any prerequisites. The SQ-V6 pointer is a routing hint rather than genuine usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does well: it discloses that the tool only returns drafting material and that 'nothing is posted by this server', plus the content constraints a post must obey (no forecast, advice, ranking, or unstated causation). It omits any note on auth, rate limits, or cost, which keeps it from a 5.

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?

Content is front-loaded with the resource and its payload, and every clause carries information about the return bundle or posting rules. The first sentence is long and clause-stacked, which slightly hurts scanability, but there is little wasted text.

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?

There is no output schema, so the description must describe the return value — and it does, itemizing all five returned components and their purpose. For a complex composite-return tool, an agent has everything needed to call it and interpret the result.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter is fully documented in the schema (100% coverage), so baseline is 3. The description adds genuine meaning beyond the schema by stating the id originates from get_events and, more importantly, that omitting it falls back to the newest events to choose from.

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 (get the post kit for one event) and enumerates exactly what the kit contains: a sentence, a link rendered as a card, a suggested chart plus side-by-side series with PNG-save pages, and the posting rules. It also distinguishes itself from get_events by sourcing the id from that tool.

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?

Gives clear usage context ('for one credit-market event') and routes the agent to get_events for the id, with an explicit fallback when no id is supplied (newest events). It does not name any of the other 20+ siblings to exclude, but no plausible alternative matches this purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does reasonably well: it discloses pagination (20 default, 500 max, cursor reuse), the descriptive-only stance ('no cause, forecast or ranking'), the collateral segregation rule, and the inclusion of Gavel's own book with own-account disclosure. It omits auth/permission needs but otherwise adds substantive behavioral context.

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?

It is front-loaded with return content and every sentence roughly earns its place, but the single dense paragraph is saturated with unexplained private jargon ('the Stack', 'bsbs, bcsi', 'Gavel's own book'), which taxes parsing. Appropriately sized for a complex tool, less appropriately styled.

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?

There is no output schema and no annotations, so the description must cover returns and behavior; it does describe the returned shape in detail (one sentence, figures and dates, the rule in words, and source) plus pagination and exclusion rules. Only permission/error behavior is absent, which is a minor gap for a read-style tool.

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 baseline is 3, but the description goes beyond the schema by spelling out what each terse enum value means (debt_move, level_cross, filing, coverage_enter/exit, etc.) and restating the default/collateral semantics in prose. It adds real meaning for the `type` filter that the bare enum 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 states a specific verb and resource ('returns the credit-market events the Stack has recorded') and enumerates the exact event types returned, so an agent knows what it produces. It does not, however, differentiate itself from the many sibling list/get tools by name, relying instead on an SQ reference to get_guide.

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 only implied, largely via the pointer 'Standard questions this tool answers (get_guide with question): SQ-M8.' No alternative sibling (e.g. get_credit_state_history, get_series) is named as the thing to use instead when the ask is not event-shaped, so the when-not case 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does so unusually well: it defines absence semantics ("says why, never zero"), the meaning of "lending not stated," the no-double-counting rule for fund/public-body shares, and the aggregation constraint on totals across dates. It also discloses the headline-vs-side-figure selection rule and that nothing is ranked, so the agent knows both scope and interpretation before calling.

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?

Every sentence carries information and the core action is front-loaded in the first clause. The density is high and the semicolon-chained clauses about sources and lending make it slightly harder to parse than a bulleted, split structure would be, but there is no filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema, the description must explain the return shape, and it does: funds by name, per-figure date/source/quote, headline selection, totals per date and their coverage window, and the raw pass-through of the route payload. It stops short of describing payload format, size, or pagination, which an agent invoking it might still want.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so per the rubric the baseline is 4. There are no arguments for the description to clarify, and the additional prose about output semantics does not attempt to invent parameter meaning.

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 opening clause states a specific verb and resource ("Lists the spot bitcoin funds and the bitcoin each states it holds") and immediately scopes the data source (SEC 10-Q/10-K, daily holdings file, periodic report). No sibling tool in the list covers fund holdings, so the agent can identify this one unambiguously from the name plus first sentence.

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 purpose: an agent looking for spot bitcoin fund holdings will recognize this is the tool. However, the description never names an alternative, never states when NOT to use it, and given 27 siblings offers no routing guidance (e.g. that it is not for futures/derivatives exposure or venue data). Implied but unstated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden and does well: counts are 'read from the data when asked' (live, not cached), the match is 'a lookup in the published list, never a guess,' and words matching nothing 'return the list' — a useful edge-case disclosure. It also declares scope limits (ranks nothing, no venue quality). Missing return-format details keep it below 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The first paragraph is a long run-on enumeration that is hard to parse, and the description runs several sentences for a one-parameter tool. The key usage instruction ('Call this first...') is not front-loaded; it appears only after the dense enumeration. Content earns its place, but structure is muddled.

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?

There is no output schema, so the description must explain returns, and it does: counts each carry a sentence saying what they count, and question matches return the call, meaning, page, and limits. Combined with the companion list of standard questions answered, an agent has enough to call it correctly, though return structure could be tighter.

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, but the description adds real semantics: 'question' accepts an id such as 'SQ-M1' or 'a few words,' and describes what a match returns (the answering call, its meaning, the page with the same figure, and limits) as well as the no-argument behavior. This goes beyond the schema's single-line parameter note.

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 states a specific purpose: a coverage guide reporting counts of the server's tools, venues, coverage, indicators, series and lenses, plus a router for standard questions. It also distinguishes itself from siblings by asserting 'It ranks nothing and describes no venue's quality,' which separates it from tools like get_venue or compare_venues. The purpose is clear though the opening enumeration is dense.

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 says 'Call this first when you need to say how much the Stack covers,' giving a concrete trigger. It also explains the two modes (no argument lists questions; with question returns a matching question), which is clear usage context. It stops short of naming alternatives or stating when not to use it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does so well: it declares the data is descriptive with no recommendation, that a missing reading is reported explicitly rather than as null/zero, that history is free and unmetered, and that recomputed indicators refuse as_known_on while vintage-kept ones return the end-of-day (UTC) publication. These are non-obvious behaviors an agent could not infer.

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 and well-paragraphed, with each paragraph covering a distinct behavior (history, descriptive nature, vintage, routing). The trailing list of eleven SQ codes is somewhat opaque and bulky, but it does point at a concrete routing mechanism (get_guide with question).

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 7-parameter tool with no annotations and no output schema, the description covers parameter behavior, missing-data semantics and vintage rules thoroughly. What is not covered is the shape of the response itself — e.g. how the 'methodology reference' is returned — which the absent output schema leaves to inference.

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, but the description adds real meaning beyond the schema — vintage semantics for as_known_on, the refusal case for recomputed indicators, and the free/unmetered status of history queries. It stops short of clarifying wrapper/series interactions in the prose.

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 and resource — 'Returns the current value of a single Aletheia indicator by id, with its methodology reference' — and immediately draws the boundary against venue-anchored indicators served by each venue's own MCP. An agent can distinguish this from list_indicators, get_series and compare_venues without opening a 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?

Gives explicit prerequisites ('Call list_indicators first to discover valid ids') and conditional guidance for include_history and as_known_on, plus the venue-MCP alternative for venue-anchored rates. It does not, however, state when to prefer this over sibling read tools like get_series, leaving some routing to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so unusually well: it discloses that the output is procedural guidance rather than market data, that it never concludes or ranks, that it introduces no figures of its own, and that no write capability exists anywhere in the server. That negative-space disclosure is exactly the context an agent needs and is not inferable from the schema.

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: the first sentence defines the artifact before anything else. Most sentences earn their place, though the trailing 'Standard questions this tool answers (get_guide with question): SQ-S2' reads as an internal cross-reference of marginal value to an agent and the em-dash phrasing is denser than needed.

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?

There is no output schema, so the description must describe the return payload, and it does: what to lead with, the tools in scope, and what the lens explicitly does not do. Combined with the no-arg/one-arg contract and the intended-use statement, it is complete enough to invoke correctly on the first attempt.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the five enum values are already fully glossed in the schema, so the schema does the heavy lifting. The description reinforces the omit-to-list behavior and frames the single parameter as a reader kind, but adds no syntax or format detail beyond what is structured. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb+resource — it returns a READING LENS, defined as a presentation procedure written for a particular kind of reader — and explicitly distinguishes it from the data-bearing siblings by stating it never concludes, never ranks, and adds no figures of its own. An agent can tell this apart from get_series/get_indicator without opening any 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?

It states the calling contract clearly (no argument lists lenses; one argument returns the full procedure) and names the intended use: read a lens before presenting anything from the dataset. It also points to the companion get_guide question SQ-S2. There is no explicit when-not or direct comparison against an alternative lens-style tool, so it falls just 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does so substantially: it discloses the bucketing method ($1,000 buckets), the 10/20/30% proximity bands, that positions are evaluated at each venue's own mark and rule, and that overflow exists. Critically, it warns that only position-by-position venues (pooled venues, Morpho, Sky) enter the map and that other venues are never scaled up, and it gives series start dates so a step is read as coverage rather than market movement. It stops short of auth, rate-limit, or pagination behavior, keeping it from a 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded and the ⚠ coverage warning is well placed, but the second sentence is a single sprawling construction ('An identity on observed positions: each bitcoin-only position at the price its OWN venue's rule liquidates it, summed into $1,000 buckets, with...') that is hard to parse on first read. The trailing 'Standard questions' pointer is useful but the whole is denser than it needs to be.

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 7-parameter analytical tool with no annotations and no output schema, the description supplies the missing context: methodology, coverage caveats, what is excluded from the map, and how history changes the shape of the result. It even names response fields (coverage, not_bucketed) that the agent must read first, partially compensating for the absent output schema. It is not exhaustive — no mention of units beyond dollars or of failure modes — but it is sufficient to call the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3 and the schema already documents id, date, from, to, level, and history. The description goes beyond that by explaining that history=true returns a daily band series rather than one day's buckets, that level defaults to market with id required below it, and that as_known_on means the bands as published at the end of that day. That added temporal semantics lifts it above baseline.

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 opening sentence states a specific computation — how much bitcoin-secured dollar debt liquidates at which bitcoin price, scoped to market/class/venue — which is far more than the name 'get_liquidation_map' conveys. It is distinguishable from siblings like get_debt_by_collateral or get_credit_state, though it never names those siblings directly. The dense 'identity on observed positions' sentence clarifies the aggregation rule rather than the purpose, so the clarity comes mainly from sentence one.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description supplies negative guidance — it does not forecast a price fall, does not rank venues, and gives no 'at risk' verdict — which usefully prevents misreading. It also directs the agent to read coverage and not_bucketed first and points to get_guide with SQ-M3. However, it never names an alternative tool or states the condition under which this map should be chosen over get_debt_by_collateral or get_credit_state, so usage is implied rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so: it discloses that series are computed from Morpho Blue only on Ethereum and Base, are not market-wide, and that a percentage describes one venue family. It also flags that no ether composition series exists yet and what the tool does in that case, which prevents a serious misinterpretation.

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-loads the core question and the critical scope warning, and each paragraph serves a distinct purpose. It loses a little to verbatim duplication of the schema's collateral description and repeated warning markers, but nothing is 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?

No output schema and no annotations, so the description must cover both behavior and returns; it describes the return shape ('observed shares with the scope that produced them') and the scope block. Auth, rate limits and exact response fields are unstated, but for a read-only data tool this is close to complete.

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 and the schema already documents the collateral enum. The description largely duplicates the schema's collateral text verbatim, but adds the behavioral consequence ('No ether composition series is served yet; with collateral: eth this says so and points to the ether figures'), which is meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific resource (composition by rate type, recourse and instrument, as observed shares) with a clear verb-less but precise scope, and implicitly separates itself from ranking-oriented siblings such as compare_venues ('no ranking of venues or instrument types'). An agent can distinguish this from get_debt_by_collateral or compare_venues without opening any 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?

Gives clear conditional usage for the collateral parameter (default btc, pass 'eth' for ether-secured credit) and a strong procedural instruction ('Read the scope block before quoting any share'). It does not name an explicit alternative sibling for the cases this tool does not cover, so it stops short of full when/when-not routing.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does substantial work: it discloses the data source boundary (Morpho Blue only, Ethereum and Base, not market-wide), that figures are gross and never netted, that they include scope/coverage/validation state, and that they are USD-denominated debt only. It omits any permission/rate/return-shape info, but for a read-only metric lookup this is close to sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded question followed by scope warnings and definitional notes; each sentence adds a distinct caveat. It is somewhat long and repeats the gross/netting point twice, but no sentence is purely filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

No output schema exists, so the description must describe the result, and it does: metric definition, time windows, source scope, and gross/netted distinction. What's missing is any guidance on returning/using results versus the overlapping credit-state siblings, leaving a small gap for an agent choosing among similar tools.

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?

Zero parameters, so the baseline is 4. The description still usefully defines the output semantics — gross not netted, USD-denominated, time windows — which compensates for the absence of a formal output schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific metric family (credit created vs. retired) with time windows (latest, trailing 30 days, since inception). It doesn't name or contrast with a sibling such as get_credit_state or get_credit_state_history, so an agent lacks sibling differentiation, but the purpose itself is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clarifies scope (MORPHO BLUE ONLY, Ethereum and Base) and says what it is not (forecast, momentum signal, demand characterization), which implicitly tells the agent when not to use it. However it never names an alternative tool or states when to prefer get_credit_state_history instead, so usage selection is only partially guided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so unusually well: nightly recomputation from an own full node, provenance of the price inputs (own fixing since 2026-10-05, legacy daily prices for older coins), attribution/licence obligations, and an explicit non-advice scope statement. It also discloses the additional returned field 'mvrv_z_score' and its meaning, none of which the agent could infer from 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?

Well front-loaded — definition first, then provenance, then return shape. Some duplication exists between the 'identity on observed chain data... nothing about what follows' sentence and the 'returns data; it does not advise' sentence, which restate the same boundary twice, but the remaining content earns its space.

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?

No output schema exists, and the description compensates by enumerating the returned object's fields (value, mvrv_z_score, as_of, inputs.*, methodology, attribution, licence, disclaimer) and flagging that attribution must be shown alongside the figures. Combined with the methodology and cadence notes, an agent has everything needed to call and correctly present the result.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and the single parameter is fully documented in the schema, including that it is currently ignored and where historical data lives. The description adds nothing about 'timestamp' itself, so the 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?

Names a specific verb and resource ('Returns the current Bitcoin MVRV ratio') and then defines MVRV precisely (market cap / realised cap, with realised cap explained). It also scopes itself against the historical sibling by noting it is the current value only, so an agent can distinguish it from get_chain_series without opening a 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 rather than stated: it tells the agent what kind of question the metric answers (SQ-Ch2, via get_guide) and that it does not advise or forecast, which rules out predictive use. However the actual routing rule — 'current only, use get_chain_series for history' — lives in the schema, not the description body, so the when-to-use-this-vs-alternatives guidance is only implicit here.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description is highly effective. It details the behavior of missing values ('an absence is a kind with its reason, never a zero'), explains the snapshot logic of 'as_known_on' (UTC), and defines the constraints of the chart plan, such as why a third unit might be refused.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely lengthy, functioning more like a detailed technical manual than a concise prompt. While the detail is necessary for the tool's complexity, it sacrifices brevity, leading to a middling score despite the high informational density.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that there is no output schema, the description is exceptionally complete. It details the content of the return value—including units, source attribution, vintages, and the two distinct chart plan variations (plan vs. only)—leaving no ambiguity about what to expect.

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?

Although the schema is complete, the description adds significant semantic value. It specifies that IDs must come from 'list_series' and clarifies that the legacy data sources (CoinGecko, etc.) are mentioned only for specific pre-2020 values, which affects how the agent should interpret historical data.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the purpose: 'Returns 1 to 13 series (ids from list_series)' and specifies the granularity ('each value with its date and kind'). It defines the scope by mentioning the default window and the option for full history via 'from'.

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 provides excellent usage guidance regarding defaults (365 days to today), the specific function of 'as_known_on', and the multiple ways the 'plan' parameter affects the return structure. It also includes a critical safety disclaimer: 'This tool returns data; it does not advise, forecast or characterise the market.'

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral load and does substantial work: it discloses that criteria are versioned and ride in the payload, that there is deliberately no composite score/stars/reliability index, and that 'unknown' and 'not_applicable' are distinct meaningful values rather than omissions. It stops short of stating read-only status or any rate/permission constraints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The prose is dense and partly redundant — the collateral/eth explanation appears twice in the body and again in the schema. The core idea (per-criterion venue data, no composite score) is front-loaded, but the middle paragraphs repeat themselves rather than advancing the reader.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only retrieval tool with no output schema, the description does explain the return shape (per-criterion cells with value and source across three pillars) and the collateral switch. Combined with 100% schema coverage, an agent has enough to call it correctly, though the exact payload fields are not enumerated.

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 schema already documents all three parameters, and the collateral text in the description is nearly a verbatim duplicate of the schema field description. It adds some interpretive value ('the six tiles and books' for the eth case, mapping to the headline include), but the baseline of 3 holds when the schema does the heavy lifting.

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 states a specific resource and scope: it returns what is known about one venue, criterion by criterion, broken into the Price/Quality/Composition pillars with values and sources. That clearly separates it from list_venues (discovery) and compare_venues (multi-venue), even though it never names them explicitly.

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 only implied. It tells the agent to supply collateral: 'eth' for ether-secured credit and points to get_guide for SQ-V2/SQ-V3, but it never states when to reach for this tool instead of compare_venues or how it relates to list_venues. The routing context is thin.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations the description carries the full burden, and it delivers: it warns that 'match' is 'unchecked' where bytecode has not been compared against verified source, that an unsettled promise says so, that mainnet and testnet return different answers because they run different builds, and that no safety score or badge exists in the payload. These caveats actively prevent the reader from over-reading the data.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The scope constraint is front-loaded, and the warning block is well-placed at the end. Some prose is florid ('the verdict is the reader's') and could be trimmed, but every paragraph carries substantive information for a tool with a rich payload and no output schema.

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?

There is no output schema, so the description must explain the return payload — and it does, field group by field group, plus the temporal ('what did the last check return') and cross-network caveats. Nothing an agent needs in order to call this correctly 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% and the single 'network' enum is fully documented in the schema itself, so the baseline is 3. The description reinforces the mainnet/testnet distinction but adds no syntax or format detail beyond what the schema already states.

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 pins the resource precisely: a bundle covering only the registry's auction venue ('gavel_arbitrum') and enumerates exactly what the payload contains (addresses, bytecode hashes, upgradeability position, privileged-function map, audit reference, five structural promises). The verb is implicit rather than stated ('Covers...', 'It is served here as...'), but the resource and its uniqueness among venues are unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives a usage context ('served here as a source for that venue's quality criteria') and an implicit exclusion ('no other venue has a bundle yet'), which routes the agent away from expecting bundles for other venues. However, no sibling is named (e.g., get_venue or compare_venues) and there is no explicit when-to-use statement.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does a solid job: it spells out the exact response shape (count, series[] with id/dataset/unit/kinds/first/last/latest_vintage/licence) and adds non-obvious domain context about the `free_attributed_only` licence flag and the pre-2020-07-13 legacy price backfills. It does not say whether the list is stable, ordered, or large enough to need pagination, which matters for a no-parameter enumeration.

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 statement, followed by the return shape and then the licence caveat — a sensible order. The middle sentence is long and carries some decorative framing ('built from one pass over every Bitcoin block on Aletheia's own node'), but the enumeration itself earns its space by telling the agent what it will find.

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?

No output schema exists, so the description usefully documents the return fields and the licence semantics itself. What remains unstated is ordering, list size, and whether ids are stable enough to hard-code — minor for a catalogue tool but the only real omission.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the baseline is 4; the description correctly presents it as an unfiltered full listing rather than implying hidden filter options.

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 and resource — 'Lists every series served from Aletheia's vintage store' — and enumerates the exact families and id prefixes (chain.cohort.*, miner.*, price.*, fx.*) it covers, which is far more precise than a generic catalogue claim. The one gap is that it never names the very similar siblings list_series / list_indicators / get_series, so the agent must infer the catalogue-vs-values distinction from the enumeration alone.

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 only implied: the enumerated prefixes and the returned `id` field suggest this is the discovery step before calling get_chain_series or get_series. There is no explicit 'call this first to find ids' instruction, no statement of when to prefer it over list_series, and no exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it does disclose non-obvious behavior: some indicators are withheld (single-venue anchored) and appear as listed-but-not-served with the serving server named. It also implies a passive read that returns a catalogue, not a ranking. It does not mention pagination, catalogue size, or response shape beyond the field list, so it stops short of full transparency.

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 and returned fields, then families, then usage. Sentences earn their place, including the withheld-indicator note. The trailing 'Standard questions this tool answers (get_guide with question): SQ-I1' is terse and slightly cryptic, but it is short and aids routing.

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 compensates by enumerating the returned fields, and both parameters are covered by the schema. It also explains what happens to non-served indicators. Minor gaps remain: no indication of catalogue size or format granularity of 'units'/'description' fields.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%: both 'family' (enum) and 'live_only' are fully documented in the schema, so the baseline is 3. The description restates the three family values but adds no syntax or semantics beyond what the schema already conveys.

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 ('Returns the catalogue of Aletheia indicators') and enumerates exactly what each entry contains (id, name, family, units, description, live status), so the agent knows what it gets back. It names get_indicator as the follow-up, which disambiguates against the lookup tool. However, it never mentions the sibling list_onchain_indicators, which sounds strongly overlapping, leaving a real sibling-confusion gap.

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 tells the agent when to use it ('Use this to discover what is available, then call get_indicator with an id') and states the exclusion ('it does not rank indicators or advise which to use'). That is clear context plus a named next step. It falls short of 5 because it does not address when to prefer this catalogue over the apparently-overlapping list_onchain_indicators sibling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it does disclose meaningful behavioral context: the output includes readiness status ('live' or 'pending'), alerting the agent that some listed indicators may not yet be usable. It stops short of stating read-only/no-side-effect guarantees or any auth requirements, but with zero parameters there is little mutation risk to convey.

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 return contents and followed by the usage cue. The enumeration of returned fields is not padding – it substitutes for the absent output schema – and no sentence is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter, read-only catalog lister with no output schema, the description supplies the missing return-value documentation (tool name, indicator name, description, units, example invocation, readiness status) and the discovery use case. Nothing an agent needs to invoke it correctly is absent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes no parameters, so per the rubric the baseline is 4. There is no parameter semantics to add and nothing misleading in the description.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a precise verb+resource ('Returns the catalog of available on-chain indicator tools') and enumerates the fields returned, so an agent knows exactly what it produces. The 'on-chain' scope implicitly separates it from the sibling list_indicators, but that sibling is never named or contrasted, so full sibling differentiation is not achieved.

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 triggering condition: 'Use this when you need to discover which tools are available for on-chain analysis without inspecting every tool definition.' That is a concrete when-to-use, though it names no explicit alternative (e.g. list_indicators, get_indicator) or when-not-to-use case.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations at all, the description carries the full behavioral burden and does so well: it discloses default page size (100) and the 500 cap, that the returned `next` is the cursor, the exact fields each row carries (id, label, unit, group, collateral, cadence, kinds, date bounds, licence, page, chartable and why, explorer coverage). It stops short of stating auth requirements, rate limits, or response ordering, which keeps it off a 5.

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 purpose, then paging, then narrowing, then the hand-off to get_series — a sensible order with no filler sentences. The long middle enumeration of datasets is dense and slightly list-heavy, but each clause does describe genuinely distinct catalogue content, so it largely 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?

For an 8-parameter, all-optional list tool with no output schema and no annotations, the description covers what an agent needs: row shape, pagination contract, filter mechanics, entry-point question IDs. Missing only auth/permission framing, which is a minor gap at this complexity level.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is already 100%, so the baseline is 3; the description adds real meaning by explaining how the filters combine and giving a concrete prefix example ('credit.class.algorithmic.') beyond the schema's own examples. It also clarifies that collateral values are 'never added together,' a semantic constraint the enum alone 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?

Opens with a specific verb and resource ('Lists the series the Stack serves, across every dataset') and then enumerates the concrete catalogue contents — credit tree levels, liquidation bands, cx measures, governed indices, Treasury curve, SOFR — which pins it apart from siblings like list_chain_series, list_indicators and list_venues. An agent can tell exactly what corpus this enumerates without opening any other 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?

Explicitly routes the agent onward: 'Then fetch values with get_series,' and 'Standard questions this tool answers (get_guide with question): SQ-Ch1, SQ-S4.' It also states the narrowing strategy (dataset, group, collateral, prefix, q) and pagination behaviour, so the when-and-how is fully specified.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does so well: it discloses ordering (registry order, no ranking or scoring), default scope (Bitcoin unless collateral: 'eth'), the meaning of coverage 'none' as a declared gap, and the return shape (one compact row per venue, per-pillar coverage state, researched-cell counts). It pre-empts misreading venue presence as an endorsement.

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 answer to 'what does this return', then scope, then caveats. Dense and mostly waste-free, though the vocabulary explanation and warning block make it long for a list tool and some wording is repeated from the schema descriptions.

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 an 8-parameter tool with no output schema and no annotations, the description covers what is needed: return shape, defaults, ordering, filter semantics, and a data-interpretation caveat. Nothing an agent needs to invoke it correctly 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 mechanical baseline is 3, but the description adds conceptual meaning beyond the field docs: the type-vs-class distinction, 'filter by either', the mutual exclusivity of collateral scopes, and that unspecified filters mean no constraint. It does not add format specifics beyond what the schema already gives.

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 and resource ('Returns the registry rows' of credit venues) and frames scope precisely with the opening question. It distinguishes itself from siblings by naming get_guide as the counting tool and by defining the type-vs-class vocabulary that compare_venues also uses.

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?

Gives clear selection context: use this to list/filter venues, use get_guide to count by type/class, and it names the standard questions (SQ-V1, SQ-V5) it answers. There is no explicit 'do not use for X' exclusion, but the routing to get_guide and the get_venue sibling boundary is clear enough.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.