The Undesirables TCG Oracle

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 the frozen-input state and required phrasing ('Say last published, never today'), the usd_panel {frozen, as_of} marker, that the call is free with no payment required, that horizon is fixed at 30 days, and that momentum grade can be 'NA' on a drift spike. This is far beyond what a typical definition offers.

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 frozen-input caveat is correctly front-loaded because it changes how any agent should phrase its answer, then the core one-card summary, then usage, then escalation. The returned-field list is long but earns its place since no output schema exists. Slightly verbose overall, but no sentence is pure filler.

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

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

Given no output schema and no annotations, the description supplies the return-object field list, the frozen-data caveat, cost model, horizon constraint, escalation path, and a sample plain_english read. An agent has everything needed to call it and to interpret the response.

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 0%, so the description must compensate, and it does partially: card_name is 'resolved to the best match' (fuzzy resolution semantics) and product_id is a 'TCGplayer product_id' (namespace semantics). It does not explain that both are optional with default empty/zero values or how the two are prioritized when both are supplied.

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 deliverable on a specific resource: 'The FREE 30-day read on ONE card: point forecast, bands, VaR, and the Safe-Hold / Momentum letter grades, in one call.' It immediately distinguishes itself from simulate_price by naming the horizon (fixed 30 days) and the exact outputs, so an agent can tell it apart from sibling forecasting 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?

Explicit routing: 'Use this FIRST for is this card a safe hold?, 30-day outlook?, how risky is X?' followed by when-not and the alternative — 'For other horizons, the full percentile curve, or Monte Carlo paths, escalate to simulate_price (paid).' It also points to a free market-overview endpoint for a different intent.

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 it discloses that the tool is free, updates daily, is cert-verified, and reports observed market census rather than pop reports. It could be more explicit about read-only behavior or response format, but the behavioral context is largely covered.

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

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

The description is dense but well organized, leading with the core purpose rethen cost/update details and use cases. Minor jargon and parenthetical asides add a bit of clutter, but each sentence 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 a zero-parameter read-only summary tool, the description covers output fields, update cadence, cost distinction, exclusions, and recommended usage. Nothing essential is missing for an agent to select and invoke it correctly.

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

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

The tool has zero parametersheb, so schema coverage is effectively complete. The description adds value by explaining what output dimensions the census summary includes, which is the relevant information an agent needs.

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 explicitly states that this tool returns census totals across PSA/BGS/CGC/TAG, including unique certs, cards covered, grader mix, and active-30d counts. It differentiates itself from the per-card paid census, so an agent can identify the tool's scope and output.

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

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

The description provides explicit use cases: sizing supply behind a grade or judging how thin a slab market is before trusting an ask. It also clarifies the alternative per-card paid census and the NOT-pop-report exclusion, giving clear selection 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 of behavioral disclosure. It discloses key behaviors: lineups are merkle-committed before games, points come from daily stat panels, sealed souls return 404 until minted, and there are two output modes depending on token_id. It does not mention authentication, rate limits, or other potential constraints, but for a read-only feed tool the provided behavior is substantial.

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 longer than minimal, but every sentence adds valuable context. It is well structured: first the league overview, then the two parameter modes, then usage guidance and a human link. It is front-loaded with the core concept and avoids redundancy, though it could be tightened slightly without losing information.

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

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

Given the tool's complexity (two modes, token_id semantics, edge cases like sealed souls) and the absence of an output schema or annotations, the description covers everything an agent needs: what it does, what it returns in each mode, the 404 case, and concrete use cases. It even provides a human-facing URL. This is complete for the tool's purpose.

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 0%, so the description must fully explain the token_id parameter. It does so precisely: no token_id yields the league feed, while a token_id (1..minted) yields that soul's full card, and sealed souls return 404. This is comprehensive and leaves no ambiguity about parameter semantics.

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

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

The description clearly states the tool's function: it provides access to a fantasy league feed for AI personalities, with two distinct modes (no token_id for league-wide data, with token_id for a specific soul's card). It also includes the context of merkle-committed lineups and daily stat panels, making the purpose unambiguous and distinct from sibling 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 explicitly lists the intended use cases ('Use this when: an agent wants...') with concrete examples, which gives clear guidance on when to invoke the tool. It does not explicitly name alternative tools or state when NOT to use it, but the specificity of the use cases effectively differentiates it from 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 provided, the description fully carries the behavioral burden and does so admirably: it discloses the $0.10 paid cost, the three accepted rails, that Solana settlement is verified, the exact returns (PSA/Beckett subgrades + overall score + free ROI verdict), and the underlying methodology (Qwen, OpenCV, BGS capping). This is rich disclosure beyond mere mutation.

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-organized and front-loaded with the core purpose and pipeline before the payment details. Slightly verbose in places — the internal audit reference ('Audit 2026-07-30, BUG-12') is arguably noise for an agent — but every functional sentence 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?

Strong coverage for a complex paid, multi-rail tool with 2 params and no output schema. The pipeline, returns, cost, rails, and usage are all present. Remaining gaps are the unexplained game parameter and whether the $0.10 payment is required before the call or settled after, which are material but minor against an otherwise complete definition.

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 0%, so the description must compensate for the two parameters, but it largely does not. image_url is only implicitly covered by 'trading card image,' and the required/default game parameter is never explained at all (what games are supported beyond the Pokemon default, what values are valid). The description adds almost no parameter-level 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?

States a specific verb+resource ('AI-grade a trading card image') and details a 3-stage pipeline that anchors the purpose. It distinguishes itself from the sibling grade_or_not by clarifying it produces an actual PSA/Beckett-calibrated grade rather than just a go/no-go verdict.

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?

Ends with an explicit 'Use this when: a user has a card image and wants to know what grade it would receive from PSA or Beckett,' which gives clear invocation context. However, it never names alternatives like grade_or_not or check_accuracy, nor states when NOT to use this 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?

With no annotations, the description carries the full behavioral burden. It discloses that values are asks rather than sold prices, that asks are a ceiling, and that the data is free, refreshed daily, sourced from eBay enrichment, and merkle-committed. This gives an agent a strong safety and trust profile.

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

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

The description is dense but front-loaded: the core scope and price-basis caveat come first, followed by freshness, source, value-layer role, and usage triggers. Some phrasing repeats the loan-terms point, but the length is justified given there are no annotations or 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?

For a one-parameter read-only tool with no output schema, the description covers the payload fields, price semantics, refresh cadence, source, cost, and typical queries. It also explains how to get product_id and when to call it in the loan-term workflow, leaving little for the agent to infer.

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 0% and the only parameter has just a title, but the description explicitly defines product_id as the TCGplayer id from search. This resolves the key ambiguity about how to obtain and supply the identifier.

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 what the tool returns: PSA/BGS/CGC median asking prices for one card, broken out by grade with listing counts, low/high, an as-of date, and an explicit price_basis. It also distinguishes itself from siblings and sold-price tools by emphasizing these are eBay asks, not sold prices.

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 includes an explicit 'Use this when' section with concrete query examples like 'what does a PSA 10 of this go for?' and 'raw vs graded premium?', and positions it before loan_terms_preview. It does not explicitly list alternatives to avoid, but the usage context is clear and actionable.

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?

The description discloses a key behavioral trait: 'PAID: $0.10 USDC per call.' It does not mention side effects, data modification, or permissions, and since no annotations are provided, the description carries the full burden. The cost is transparent, but the lack of any statement about read-only behavior or side effects leaves some ambiguity, yielding a middling score.

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 concise and well-structured: it leads with the core questions, explains the methodology, states the output, and adds a usage condition. Every sentence adds value and there is no fluff, making it highly efficient for an agent to parse.

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

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

Given the tool's moderate complexity (4 parameters, no output schema), the description provides sufficient context: it explains the inputs' general role, the calculation approach, and the output format (GO/NO-GO with best/predicted/worst profit). It does not cover error cases or edge conditions, but for a straightforward decision-support tool this is adequate, so it earns a strong but not perfect score.

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

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

The schema provides only parameter names and defaults with no descriptions (0% coverage). The tool description mentions concepts like 'AI grade prediction' and 'PSA fee schedules' that implicitly relate to predicted_grade and service_tier, but it does not explicitly define each parameter or clarify nuances such as the meaning of raw_price or allowed values for service_tier. This falls short of compensating for the absent schema documentation.

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

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

The description clearly states the tool answers 'Should I grade this card?' and 'Will I make money?' by combining AI grade prediction with PSA fees, shipping costs, and market values to return a GO/NO-GO verdict and profit scenarios. This is a specific, verb-driven purpose that distinguishes it from sibling tools like market_snapshot or grade_card.

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 explicitly states 'Use this when: a user is deciding whether to submit a card for professional grading and wants to know if it's financially worth it.' This provides a clear trigger condition, though it does not explicitly contrast with alternatives or state when not to use the tool, so it falls just short of a perfect score.

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 were provided, so the description carries the full burden. It reveals that the tool is FREE, refreshes once per ingest day, and is LIVE while the USD panel is frozen, which is useful behavioral context. It does not explicitly state that it returns no card names or prices, but that is implied by 'as numbers — no card names or prices.' Given the lack of annotations, this is strong disclosure, though it could be more explicit about being a read-only, non-mutating operation.

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 a single dense paragraph, which is efficient but could be structured with a brief lead sentence and bullet points for the metrics. It front-loads the key point (market summary as numbers) and then details specifics. It's not overly verbose, but the wall-of-text format hurts readability.

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 tool with no output schema, the description thoroughly covers what the tool does, the data it provides, and usage guidance. It also differentiates from siblings. There is nothing missing that an agent needs to call it correctly or interpret results.

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

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

With zero parameters, the schema is trivial (empty object), so the description carries the full burden. The description richly explains what the tool returns, covering counts, price bands, depth, movement, and Merkle root, which goes beyond what an empty schema could convey. Baseline for 0 params is 4, and the description meets that by clarifying the exact data content.

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

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

The description clearly states the tool reports on the Japanese card market with specific metrics (counts, dealer bid/ask, depth, movement, Merkle root), and distinguishes it from related tools like market_snapshot by noting it is the only LIVE Japanese panel while the USD panel is frozen. The verb 'summary' is enhanced by concrete detail.

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

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

The description provides explicit when-to-use scenarios: 'what did the Japanese market do today?', 'is the dealer paying more or less for cards this week?', and before reasoning about any single Japanese card. It also mentions the per-card page as an alternative route, clarifying that this tool is for aggregate market data, not individual card details.

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 the free/paid split, the top-250 census-depth gating, the 404 fallback pointing at the x402 paid quote, the discontinued raw-card quotes, and a frozen USD level. It adds real behavioral context beyond any structured field. It stops short of auth mechanics or rate limits for this endpoint.

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 the core purpose and an explicit 'Use this when' closer, which is good structure. However, the long parenthetical derivation chain (realized sales > delisting-inferred sales > ask median x 0.85 ...) and the interleaved pricing/gating details make it read as a run-on paragraph where several clauses do not earn their place for tool selection.

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 supplies most of what an agent needs: scope, gating rules, fallback behavior, related universe endpoint, and an informational-only disclaimer. Gaps remain on product_id's meaning and what the six-step derivation actually returns, but for a preview 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 0%, so the description must compensate. It does for two of three params: grade is given a format example ('PSA 10') and its omission default (the slab's deepest-census grade), and term_days is constrained to 7, 14 or 30 as free text. product_id, the only required parameter, is never explained, leaving the caller to infer it is a slab identifier.

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+resource: a free, worked derivation of lending terms (max LTV) for a graded slab, with a named date-stamped methodology. It explicitly distinguishes itself from the paid /api/v1/loan-terms quote endpoint, so an agent can tell the two apart. It does not differentiate from other siblings (market_snapshot, simulate_price), and the dense parenthetical derivation chain slightly muddies the core purpose.

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 an explicit 'Use this when' clause: collateral math for a slab, or explaining how the oracle derives an LTV before paying for a full quote. It also names the alternative (/api/v1/loan-terms) and the condition that routes to it (non-free-board slabs return 404). No explicit when-not guidance beyond the 404 case, so it falls 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 behavioral burden. It discloses that results are paginated, explains the page size rationale, notes the free_board flag condition, and mentions the version change (graded slabs only). It does not explicitly state it's read-only, but the context makes that obvious. It also does not mention rate limits or error behavior, but for a read-only listing tool, this is adequate.

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 organized into clear sections: purpose, paging caveat, parameter list, and usage note. Every sentence adds value—none are redundant. The critical paging warning is front-loaded, and the parameter list is concise.

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 paginated listing tool with four optional parameters and no output schema, the description covers the return shape (fields like grade, ask median, etc.), the page metadata (total_matching, returned), and the use case. An agent can call it correctly and interpret the response without additional documentation.

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 0%, so the description must explain every parameter. It does: limit (default 50, max 500), tier (enumerated values), free_board_only (boolean), min_value_usd (0 = no floor). This fully compensates for the lack of schema descriptions, giving agents clear guidance on valid inputs and defaults.

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 explicitly states the tool lists graded slabs the Loan-Terms Oracle will quote, with specific fields (grade, ask median, census depth, etc.), and distinguishes itself from sibling loan_terms_preview by noting the free_board flag. It also mentions versioning (v2) which clarifies 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?

Provides a clear 'Use this when' section stating it's for obtaining a product_id+grade for terms or checking collateral depth, and implies alternatives (loan_terms_preview for the actual quote). The paging warning also guides agents to set appropriate limits.

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 the suspended state, the 200 {status: suspended} response shape, the no-charge behavior, the resume condition, the $0.025 USDC/x402 paywall and the historical audit note about the previously incorrect FREE documentation.

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 critical suspension/cost information is correctly front-loaded, but the body is bloated with internal audit references ('External audit 2026-07-30, BUG-2') and restated pricing history that add length without helping an agent select or call the tool.

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 suspended zero-output-schema tool the description is largely complete: status, cost, response shape, alternatives and resume behavior are all covered. The one real gap is the undocumented 'game' parameter, which leaves the only invocation input underspecified.

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 0% and the single 'game' parameter has no description or enum. The text partly compensates by implying the parameter is optional and filters to one of '25 supported card games,' but it never names valid values or the expected format, so an agent cannot construct the argument confidently.

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

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

The description names a specific deliverable: 'The DAY'S MARKET REPORT in one call, optionally for one game,' enumerating gainers/losers, volume leaders and a 25-game breakdown, and explicitly contrasts itself with trending_cards ('a summary of the whole market, not a ranked pick list'). The purpose is clear and sibling-differentiated, though it is buried beneath a dominant suspension notice that an agent will read first.

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 explicit when-to-use ('a user asks what happened in the card market today'), explicit alternatives with the condition that selects them (trending_cards for a ranked pick list; loan_terms_preview, sports_board, or the /jp/card/... page while suspended), and states the tool does not charge. Nothing 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?

No annotations are provided, so the description carries the full burden, and it does substantial work: it discloses a hard cost ($0.50 USDC per call), that the tool is currently suspended since 2026-09-12 with the reason, that calls do NOT charge while suspended, and that the oracle returns a 200 with a status payload. The main gap is that it doesn't address auth or rate limits, but the cost/suspension/behavioral disclosure is well beyond a typical definition.

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 suspended banner is front-loaded and informative, but the whole block is oversized for what it communicates: the suspension story, the resume logic, the alternatives list, then the actual purpose, cost, and usage. Several sentences could be tightened without losing signal, and the core purpose arrives deep into the 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?

With no output schema, the description usefully enumerates what the caller receives (optimal position sizing, per-card allocation weights, Sharpe ratios, rebalancing recommendations), and with no annotations it covers cost and live-status behavior. Missing only the 'days' parameter, which leaves a small schema gap rather than a comprehension gap.

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 0% and all four parameters are undocumented in the schema, so the description must compensate. It mentions 'comma-separated card names, budget, and risk tolerance' — adding a format detail (comma-separated) — but omits the 'days' parameter (default 90) entirely and gives no detail on valid risk_tolerance values or budget units.

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 ('Optimize a trading card portfolio') and names the underlying techniques (Markowitz mean-variance, Merton jump-diffusion Monte Carlo), which distinguishes it from forecasting/valuation siblings like card_forecast or simulate_price. It is clear what the tool does, though the suspended-status banner occupies the more prominent front position.

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 gives a use condition ('when a user has a budget and wants to know how should I allocate my money across these cards?') and names live alternatives (loan_terms_preview, sports_board, the free /jp/card page) for the suspended case. When-to-use and when-to-use-something-else are both present.

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 of explaining behavior. It clearly discloses the outputs: calibration coverage, on-chain track record, grading study, and verifiable merkle-commitment timing. It does not mention potential errors, rate limits, or exact output format, but for a no-argument scorecard tool, the key behavioral aspects are covered.

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 somewhat stylized with rhetorical flourishes like 'check us before trusting us' and the parenthetical 'do the 90% bands actually cover 90%?', but it remains reasonably compact. The key details are front-loaded, and the 'Use this when' section provides actionable guidance without excessive bloat.

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 compensates by summarizing the main returned elements: rolling 30-day coverage, recent 93.3% figure over 181K+ predictions, on-chain track record, and grading study. It also provides the merkle-commitment context for verifiability. It could be more precise about the exact response structure, but for an agent deciding whether to call this scorecard, the context is sufficient.

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

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

The input schema has zero parameters, and the description explicitly states 'no arguments.' There are no parameter semantics to explain, and the statement removes any ambiguity about invocation requirements.

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 identifies the tool as an oracle scorecard that returns rolling 30-day calibration coverage, on-chain track records, and a blind grading study. It states that it takes no arguments and frames its purpose as a trust-but-verify check, making the tool's function easy to distinguish from forecast or loan 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 explicitly says 'Use this when: an agent wants evidence the calibration claims are real, or a trust-but-verify check before paying for forecasts or loan terms.' This gives clear conditions for use, though it does not name specific sibling tools or explicitly state 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?

No annotations exist, so the description carries the full burden. It discloses the free nature ('FREE — no payment required') and implies read-only behavior (it recommends calls rather than executing them), though it does not explicitly mention side effects or limitations. Adequate but not exhaustive.

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 well-structured with clear sections: purpose, free note, examples, and usage guidance. It is concise despite the examples, with no redundant or unnecessary content.

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 tool with a single parameter and no output schema, the description gives all necessary context: what it does, when to use it, and how to provide the input. It is complete for an agent to decide and invoke it correctly.

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

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

The schema has only a 'goal' property with no description. The tool description explains how to fill it ('Describe your goal in natural language') and provides concrete examples, significantly adding 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 verb ('get') and resource ('recommended sequence of TCG Oracle API calls') with a clear purpose (accomplish a goal). Differentiates from siblings by focusing on workflow recommendation rather than performing a specific 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?

Explicitly provides usage guidance: 'Use this when: you're not sure which tool to call first, or need a multi-step workflow recommendation.' This clearly indicates when to choose this tool over 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 and no output schema, the description carries the full burden and does so admirably: it discloses that USD prices are FROZEN at a stated date, that each price has its own as-of date, that a live Japanese-print panel refreshes daily, and that the operation is free. It also states what is returned (names, IDs, market prices) and warns not to present USD prices as current.

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 and headed, but repetitive: the frozen-USD-price warning appears in the opening NOTE and again under FRESHNESS with overlapping content ('FROZEN at 2026-09-07' vs 'FROZEN at their last good date'). The redundancy costs space without adding information.

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 search tool with no annotations and no output schema, the description covers purpose, freshness caveats, return contents, and query strategy well. Its main omissions are the semantics of the `game` and `limit` parameters, which leaves the definition slightly incomplete for correct invocation.

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 0%, so the description must define all three parameters. It thoroughly clarifies the `query` parameter (both card and set names searchable, rarity/condition words not indexed), but never explains the `game` filter or the `limit` parameter, leaving two of three params undocumented in any field.

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 with explicit scope: 'Search 456K+ TCG products across 25+ card games.' It also distinguishes itself from siblings by describing the product_id handoff to card_forecast, grade_or_not, and simulate_price, so an agent knows this is the entry-point search rather than a pricing/forecast 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?

Provides an explicit 'Use this when' clause plus a detailed search strategy (card name alone vs adding set, removing rarity/condition words, fallback when empty). It routes to alternatives after a search, but gives no explicit when-not-to-use or comparison against another lookup 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?

With no annotations, the description carries the full burden and does so: it discloses suspension status, the frozen source, the exact oracle response shape (200 with status suspended), that no charge occurs, the auto-resume condition, and the per-call price ($0.015 USDC). That is unusually rich disclosure of state, cost, and failure behavior.

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

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

The most urgent fact (SUSPENDED, does not charge, prefer these live tools) is front-loaded, which is correct for an agent deciding whether to call at all. It is longer than ideal with several paragraphs, but each block (status, simulation behavior, pricing, sibling contrast) contributes distinct information.

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 annotations and no output schema, yet the description explains the return payload (5th-95th percentiles, model parameters, confidence intervals, optional MC paths), the cost, the required input, and current operational state. An agent has everything needed to decide and to call correctly, with only 'simulations' 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 0%, so the description must compensate, and it mostly does: days range 30..365 with default 90, model options 'gbm'/'merton' with default 'conformal', and current_price required. The only omission is the 'simulations' parameter (default 20000), which is undocumented in both places.

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 ('SIMULATE a card's price path over a horizon') and names exactly what the output contains (percentiles, model parameters, CIs, Monte Carlo paths). It also explicitly distinguishes itself from card_forecast, so an agent can route without opening either 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 when-to-use ('only when the user wants a different horizon, the full percentile curve, or a Monte Carlo model') and when-not (card_forecast is the free fixed 30-day read). It further names live alternatives (loan_terms_preview, sports_board, the free /jp/card page) and even the exact trigger phrase '6 months out?'.

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 behavioral context: it is FREE (no payment required), and each open call is provably committed before the outcome via lock_hash, week's merkle root, and on-chain tx. That verification semantics is exactly the kind of trait annotations would otherwise provide. It omits return format details, pagination, and invalid-id 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?

Purpose and cost are front-loaded, then usage, then argument details — a sensible order with no wasted filler. The Args block is slightly verbose, but every sentence conveys non-obvious information, so structure is strong.

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

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

For a single-parameter read tool with no annotations and no output schema, the description explains what comes back (open locked predictions plus recent scored results, with lock_hash, merkle root, and tx) and covers the id bounds. Error handling and result size are unaddressed, so it is complete but not exhaustive.

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 0% (the schema only says 'Token Id': integer), so the description must compensate, and it does richly: valid ids run 1..total_minted, total_minted is read live from GET / on the oracle (274 as of 2026-09-12), it grows as souls mint, and it must never be hardcoded. This is meaningful semantics well beyond the bare 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 verb and resource — 'Full public record for ONE Undesirable soul: every open (locked) prediction and its recent scored results' — which an agent can immediately distinguish from a list-style sibling like souls_in_wallet. It does not name a competing sibling explicitly, so it falls short of a 5, but the singular scoping ('ONE') makes the intent 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 'Use this when:' clause gives explicit context — inspecting a specific soul's calls in detail, or verifying one — which is clear activation guidance. It does not name an alternative tool or state when NOT to use it, so it stops short of the explicit when/when-not/alternative bar for 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 excellently: it explains ownership is read from Ethereum mainnet at a specific ERC-721 contract, that only minted souls 1..total_minted have records, that no wallet connection or proof of ownership is required, and critically that ratings read UNRATED until 2026-07-31 and that this is expected rather than an error.

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 and follow-up sections (HOW IT WORKS, WHAT YOU GET BACK, IMPORTANT) that are well-organized and mostly earn their place. It is longer than strictly necessary, with some prose that could be tightened, but the density is justified by the tool's complexity.

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 must cover both, and it does: it enumerates the return fields (souls[], wallet_totals, best_soul) with per-field detail, and supplies the safety/permission and timing context an agent needs to interpret results 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 0% (params are bare 'address' and 'calls'), so the description must compensate and does: address is a '0x-prefixed EVM address to look up' and calls is defined as 'recent scored calls to include per soul (0-12, default 5)', adding the valid range the schema omits.

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: 'Show every Undesirable soul a wallet holds, with each soul's public prediction track record and its most recent calls.' This is clearly distinguishable from sibling roster-style tools like soul_calls or oracle_scorecard.

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 'Use this when' clause gives concrete triggering scenarios (what they own, how souls are performing, which is most accurate) and adds roster-specific guidance ('Offer to compare them, or to speak as a specific one'). It does not, however, name sibling alternatives or explicit when-not-to-use conditions, so it stops 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 provided, the description carries the full behavioral burden and does so well: it discloses the tool as FREE, states that the off-season leagues report themselves dormant rather than serving frozen numbers, and says every response includes an out-of-sample calibration verdict. It leaves rate limits, authorization, and failure modes unspecified, which keeps it shy of 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 definition is compact (about 115 words), front-loaded with the core purpose, and organized with a distinct 'Use this when' paragraph. Only 'provable, not vibes' borders on fluff, though it does earn some value by restating the on-chain provenance claim.

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 a no output schema and no annotations, the description compensates well by enumerating what returned content looks like (players, forecast context, grades, headshots, calibration verdict). It does not describe response shape or pagination, and the 'limit' parameter remains opaque, so it is strong but not fully 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 0%, so the description must encode parameter meaning. It does for 'league' via examples ('hot in MLB') and league-specific behavior, but 'limit' is never mentioned, leaving its bounds and effect entirely implied. The partial compensation for the parameter that actually concerns the table yields a 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 description states a specific resource and action: 'Daily sports movers board — hot, high-performing players per live league' with forecast context, Heat/Form grades, and headshots. It is clearly distinguished from the sibling tools (cards, games/tech) and from the paid /api/v1/sports/forecast endpoint that the description names 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?

A literal 'Use this when' block lists three triggers: hot-player queries ('who's hot in MLB'), fetching player ids for the paid forecast endpoint, and fantasy-adjacent context. It does not name alternative sibling tools or give any explicit when-not-to-use rule, so it is clear context but not the spread-sheet exclusions that would earn 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 full responsibility for behavioral disclosure. It states that the tool is FREE, that leagues appear only when in season ('on the board'), that absent leagues return zero players (honest answer), and that the ids are consistent with the paid forecast endpoint. This gives the agent clear expectations about cost, data currency, and edge-case behavior.

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

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

The description is moderately long but every sentence adds value: it defines the directory, explains the 'on the board' logic, clarifies cost and id linkage, and gives explicit use cases. The structure is front-loaded with the primary purpose and ends with 'Use this when', making it easy to scan. It is not overly verbose, but could be tightened slightly.

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

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

For a simple lookup tool with no output schema and no annotations, the description covers the core information: what data is returned, when to use it, parameter meaning, and behavior for missing leagues. It implies a list of players but does not detail response format or pagination, which are not critical for this simple use case. Overall, it is sufficiently 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?

The input schema provides zero parameter descriptions (0% coverage), so the description must compensate. It explains the 'league' parameter by listing valid values (mlb, nba, ncaab, ncaaf, nfl, nhl) and describes 'query' as a 'name fragment', implying partial match. This covers the essential semantics, though it could be more specific about case sensitivity or formatting.

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 identifies the tool as a sports player directory, specifying the resource (players) and the fields returned (ids, names, teams, positions). It distinguishes itself from siblings like sports_board (a board view) and fantasy_league (a league-specific tool) by focusing on player enumeration and ID lookup. The phrase 'on the board' adds context about league availability, making the purpose unambiguous.

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

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

The description explicitly states when to use the tool: 'an agent has a player name and needs the id, or wants to enumerate a league's roster on the stat panel.' It also clarifies behavior for absent leagues (returns zero players). However, it does not mention alternative tools for when this tool is not appropriate, so it falls short of the top tier that names specific alternatives.

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?

The description discloses some data structure (agent entries include a flag and model label) but does not explicitly state side effects, authentication requirements, or rate limits. It does not say whether the tool is read-only or if it modifies anything. Since no annotations exist, the description carries the burden, and this partial disclosure is insufficient for 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?

The description is concise, using two sentences and a dash/semicolon style. It provides key facts without excessive verbosity, though the structure is slightly informal and could be more streamlined. Overall, it is well-organized and easy to parse.

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

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

The description lacks contextual information about when to call this tool, what a typical use case would be, or how it fits into the broader workflow. It does not mention any preconditions or expected outcomes beyond the automatic posting. An agent would have limited basis to decide when this tool is appropriate.

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

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

The tool has zero parameters, and the schema fully documents that fact (100% coverage). The description adds no parameter-specific details, but none are needed. This aligns with the baseline of 3 for high schema coverage where parameter info is already complete.

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 identifies the tool as a shared leaderboard for 'Biggest Scores' involving humans and AI agents, and notes that winning a game posts scores automatically. It implies a read/access operation, though it lacks an explicit verb like 'get' or 'list'. This is a minor gap, but the overall purpose is evident.

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

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

No guidance is provided about when to use this tool vs. alternatives. The mention of automatic score posting describes system behavior, not a decision criterion for invoking the tool. There is no comparison to sibling tools or any context that would help an agent choose this tool over others.

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 of behavioral transparency. It discloses key behaviors: advancing the day, resolving events, returning new state, the one-order-per-crew-member limit, and the effect of an empty orders list. It does not mention potential side effects such as turn consumption or failure modes, but covers the primary behavioral aspects.

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

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

The description is concise overall but contains slight redundancy: the orders structure and the empty orders behavior are each mentioned twice. It could be tightened into a more structured format, but it remains readable and directly to the point without unnecessary 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?

The description covers the input format, action types, the special empty-orders case, and the source for targetId. It gives a high-level expectation of the output ('events + new state'). It does not detail error handling or additional constraints, but for a game move tool the provided context is adequate for an agent to use it correctly.

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

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

The description fully explains both parameters. For 'orders', it specifies the list structure (agentId, targetId, actionType) and enumerates all valid actionType values. For 'targetId', it directs the user to obtain valid values from syndicate_state lists. 'session_id' is implied as the game session identifier. The schema itself has no descriptions, so this textual coverage is comprehensive.

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

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

The description clearly states the tool's specific function: submitting one day of orders to the Syndicate game and receiving the resolved day with events and new state. It uses a specific verb ('Submit') and distinguishes the resource ('one day of orders'). While it doesn't explicitly contrast sibling tools, the purpose is unambiguous and self-contained.

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 explains what the tool does but does not explicitly state when to use it versus alternatives like syndicate_state or syndicate_leaderboard. It implies usage (for submitting orders) and covers edge cases like empty orders (passing the day), but lacks direct when-to-use or when-not-to-use guidance relative to sibling tools.

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 of explaining side effects. It mentions starting a new game and returning a sessionId, crew, capital, and target list, but does not disclose whether starting a new game overwrites or creates additional sessions, or whether re-reading has any side effects.

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 contains marketing language ('FREE', 'you (the agent) can play', 'Same city, same rules, same leaderboard') and a strategy tip that are not essential for invoking the tool. A more focused description of the state retrieval/creation behavior would be significantly more concise.

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

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

The description provides the main usage pattern and a link to full rules, and it lists the fields returned on a new game. However, there is no output schema and the response shape for an existing session is not explicitly described, leaving some ambiguity about what 'current state' includes.

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 session_id is explained in the description: omitting it starts a new game, while providing it re-reads the current state. This compensates for the schema's lack of a parameter description, though it does not specify the expected format or source of session_id.

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 indicates that the tool starts a new Syndicate game when no session_id is provided and re-reads the current state when a session_id is included. However, it does not use a crisp verb-noun phrase like 'get game state' and includes some promotional framing.

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?

Some usage guidance is present: omit session_id to start, include session_id to re-read. But it does not explicitly contrast this with sibling tools like syndicate_move or syndicate_leaderboard, nor does it state when this tool should be preferred over them.

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?

The description states the tool is read-only, free, and takes no arguments, which gives some behavioral transparency. However, it does not concretely describe what the returned data will look like or what 'can and cannot do' actually encompasses, leaving some ambiguity.

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 relatively brief and front-loads the core purpose. The formatting is a bit cluttered with slash-separated phrases, but it remains compact and does not waste words.

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

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

The description gives enough context to choose the tool and understand its general scope, but it lacks detail about the output format or the exact contents of the API docs and proof feed. Since there is no output schema, a bit more specificity would improve completeness.

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

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

The tool has no parameters, and the schema coverage is 100% with an empty properties object. The description reinforces that there are no arguments, so parameter semantics are fully satisfied.

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 the tool is a read-only reader for technocore.chat API docs and a verifiable price feed, with a clear use case for learning about the API or verifying the feed. It is somewhat convoluted but sufficiently distinguishes this tool from the room/message/note readers.

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 explicitly says 'Use this when: an agent wants to learn the technocore API itself or verify our feed.' It also gives an exclusion: 'For rooms, messages, or notes use the other three readers,' providing clear when-to-use and when-not-to-use 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. It clearly states 'FREE, read-only' and 'READ', disclosing the non-mutating nature. It does not cover error handling or edge cases (e.g., missing key), but for a simple note read this is acceptable. It adds the context that this is a shared store for agent-published state, which is useful.

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 short, focused sentences. The first sentence front-loads the purpose and key constraints (read, key-value, namespace+key, free, read-only). The second provides usage guidance. Zero wasted words.

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

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

For a simple read-only note retrieval tool with no output schema, the description covers the essential aspects: what it does, when to use it, and how it differs from siblings. It does not explicitly state the return format, but the phrase 'READ one shared KEY-VALUE NOTE' implies the value is returned. Given the simplicity, this is adequate.

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 0%, so the description must compensate. It explains that namespace and key together identify the note, giving the core semantics. However, it does not clarify that key is optional (default '' in schema) or describe the expected format or behavior when key is omitted. The description adds value but is not fully compensating for the absence of schema descriptions.

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 ('READ') and resource ('one shared KEY-VALUE NOTE') and explicitly names the identifier components (namespace + key). It also distinguishes from sibling technocore_room by noting it is not for conversation, making the purpose unmistakable.

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?

Provides explicit when-to-use guidance ('when an agent needs a value another agent published') and explicitly states what it is not for ('Not for conversation — that is technocore_room'), naming the alternative. This fully routes the agent.

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?

Although no annotations are provided, the description explicitly states 'FREE, read-only — structurally incapable of posting.' This discloses the key behavioral trait of having no side effects, which is a major risk factor for tool use. There is no contradiction with annotations.

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

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

The description is compact, well structured, and free of unnecessary detail. It packs the core behavior, side-effect profile, usage scenario, and sibling-tool references into just a few lines without losing clarity.

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

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

Given the low complexity and the fact that no output schema is present, the description provides enough context for an agent to choose and call the tool for its primary purpose. It could be slightly more complete by describing the return format, but it already implies that messages are returned and gives sufficient alternatives for related tasks.

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

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

The description indirectly explains the 'room' parameter by saying 'one named room' and pointing to technocore_rooms for room names, but it does not explain the 'limit' parameter at all. Since schema description coverage is 0%, the description should have compensated by covering both parameters; it only partially covers one.

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 ('READ') and a specific resource ('recent MESSAGES in one named room'), and distinguishes this tool from related tools such as technocore_rooms and technocore_note. It is clear what the tool does and how it differs from its siblings.

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 explicitly says when to use it ('follow one room's conversation ... without joining') and gives direct guidance for alternatives: get room names from technocore_rooms and use technocore_note for published state values. This gives an agent clear selection criteria.

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?

It explicitly says 'read-only' and 'FREE', covering side effects and cost. However, the claim 'no arguments' is inaccurate given the limit parameter, and no annotation corroborates these traits.

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 partially concise but includes extraneous marketing context ('Flop Network', 'agent economy L1') that does not aid invocation, and the false 'no arguments' statement adds noise.

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?

It provides an overview and pointers to related tools, but omits any explanation of the limit parameter and misrepresents the argument list, leaving important invocation details unresolved.

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

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

The schema exposes an optional 'limit' parameter with no explanation, and the description actively denies any arguments, which is misleading and leaves the limit parameter undefined.

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 verb 'LIST' and the resource 'rooms', and explicitly says 'Start here to discover room names', making the purpose unambiguous.

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

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

It provides a sequencing hint ('Start here') and lists related tools as next steps, but does not explicitly state when to avoid this tool or contrast it directly with alternatives.

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: it discloses the suspension state, that the oracle returns 200 with status=suspended, that it does not charge, the resume condition, and the $0.025 USDC per-call cost. It also pro-actively warns that band/VaR percentages are regime-level constants (not a per-card fit) and that sales volume/view counts are absent from the dataset.

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 operational content is useful, but the front-loaded suspension notice and two dated NOTE blocks crowd out the core purpose, which appears only after the temporary status text. Several sentences (the 2026-07-30 correction, the regime-constants caveat) earn their place, but the ordering makes the definition slower to parse 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 paid, currently-suspended tool with no output schema and no annotations, the description covers cost, status, resume condition, usage routing, substitutes, and dataset caveats, and even points into the response ('see ranked_by'). The remaining gap is parameter semantics, which is addressed elsewhere only weakly.

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 0% for all three parameters, so the description must compensate, and it does so only by naming them: 'Filter by game, limit, and min_price'. There is no guidance on accepted game values, the price currency/units, the maximum limit, or filtering behavior — the schema property names plus defaults are essentially all an agent has.

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?

It names a specific verb and resource — 'a RANKED LIST of individual cards by PRICE VELOCITY (drift), highest absolute movement first' — and explicitly scopes it as 'built for picking cards, not for summarizing the market', which separates it from market_snapshot. An agent can identify the output shape (per-card risk row, bands, VaR, grades) without opening anything else.

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 'Use this when' block gives a concrete trigger ('which cards are moving fastest right now?') and names the alternative for the other case (market_snapshot for whole-market summaries), plus live substitutes loan_terms_preview and sports_board. Both when-to-use and when-not are explicit.

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