SqueezeOS — Institutional AI Market Intelligence

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

With no annotations, the description carries the behavioral burden. It discloses pricing ('Full report... costs 0.25 RLUSD') and free summary availability, which is useful. However, it does not explain authentication requirements (e.g., payment_token from verify_payment) or what happens on unpaid attempts; these are only in the schema. No contradiction with annotations exists.

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

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

The description is two sentences, but the first contains branding and a metaphor ('ComScore for AI agent commerce') that adds some noise. The second sentence is highly informative. Overall it is economical and front-loaded with the core action, earning a 4.

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, the description provides adequate output context ('aggregate statistics... conversion rates, and traffic patterns'). It also covers pricing and use case. The schema documents all parameters. Minor gaps (error handling, payment process) are not critical for a read-only intelligence tool, so a 4 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?

Schema description coverage is 100%, so the baseline is 3. The description does not add meaning beyond the schema—e.g., it mentions 'summary' and 'report' but not the full view enum or hours semantics. It does not compensate for parameter ambiguity, though schema is self-sufficient.

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 'Returns aggregate statistics on which AI systems... conversion rates, and traffic patterns' with a specific resource (Agent Economy Intelligence Network™). It distinguishes itself from siblings by focusing on AI agent commerce analytics, a unique niche among the listed 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 provides explicit guidance: 'Use this to understand the AI agent commerce landscape before building on or citing SqueezeOS.' It also clarifies free vs. paid access. It does not mention exclusions or alternatives, but the context is clear enough for an agent to decide when to invoke it.

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

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

With no annotations provided, the description carries the full burden. It discloses polling interval, confidence threshold, sizing mechanism, routing, live vs. shadow mode gating, and the return object shape. While some details (e.g., what 'fires' does precisely, error handling) are not covered, the description is quite transparent about the core behavior and 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 is a single paragraph of about 70 words, front-loaded with the core purpose, then concise details on auth, mechanics, and mode. Every sentence contributes meaningful information without redundancy.

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

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

For a tool with one optional parameter and no output schema, the description covers the essential context: activation, authentication requirements, operational mechanics, live vs. shadow mode, and return format. It provides a comprehensive picture without being verbose.

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 describes the 'operator_key' parameter as an alternative to the header. The description reinforces this and adds the important context that the server-side env var OPERATOR_API_KEY is set to configure the key. This goes beyond the schema by clarifying the relationship between parameter, header, and environment variable.

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 primary action ('Activate the Sovereign Autopilot') and then elaborates on what the autopilot does: polls OracleEngine, fires based on confidence thresholds, sizes via Kelly Criterion, and routes to Tradier API. This distinguishes it from sibling tools like autopilot_stop or autopilot_status.

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 prerequisites: X-Operator-Key header (with env var reference), TRADIER_LIVE must be true for real orders, and shadow mode otherwise. It implies when to use (to start the autopilot) but does not explicitly mention when not to use or compare with alternatives. This is clear context but lacks 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 provided, the description carries the full burden of behavioral disclosure. It explicitly states the tool is read-only, free, requires no auth, and is safe to call at any frequency. It also enumerates the exact return fields, providing complete transparency about what the agent will receive.

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 sentence, front-loaded with the core purpose ('Read-only status'), followed by a comprehensive list of return fields. Every phrase adds value, with no redundancy or filler, making it highly efficient.

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 has no parameters and no output schema, the description must explain the return values itself. It does this exhaustively, listing all fields (active, live_mode, watchlist, confidence threshold, Kelly fraction, etc.) and operational details like auth and safety. The description is fully self-contained for an agent to invoke 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 parameters, which earns a baseline of 4. The description correctly does not attempt to explain parameters that do not exist, and no additional parameter semantics are needed.

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 that this tool provides read-only status of the Sovereign Autopilot, with a specific verb ('Read-only status') and resource ('Sovereign Autopilot'). It distinguishes itself from sibling tools like autopilot_start/stop/trades by explicitly being a status read, listing the exact fields returned.

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 gives explicit context: 'Free — no auth required' and 'Safe for any agent to call at any frequency', indicating when it can be used without restrictions. It does not explicitly name alternatives or exclusions, but the read-only nature and return field list make its purpose clear relative to control tools like autopilot_start/stop.

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 discloses key behavioral traits: immediate halt, no position closing, header requirement, and return format. It leaves some details (e.g., reversibility) unstated but covers the core behavior expected of a stop command.

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

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

Three sentences, each presenting a distinct piece of information: the main action, an important exclusion with alternative, and authentication plus return value. No filler or redundancy.

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

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

For a simple single-parameter tool with no output schema, the description covers the primary action, a critical limitation (no closing positions), alternative tool, auth method, and return shape. It's missing an explicit 'when to use' statement, but the purpose is strongly implied.

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 only lists 'operator_key' with no description or required flag (0% coverage). The description clarifies it is passed via X-Operator-Key header and is required, adding essential context that the schema fails to provide.

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 action ('Halt the Sovereign Autopilot') and distinguishes from sibling tools by explicitly noting it doesn't close positions, which differentiates it from autopilot_start, autopilot_status, and autopilot_trades.

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 explicit alternative usage ('use autopilot_trades to review then manage manually') and mentions the required X-Operator-Key header, giving clear context for when to use this tool versus 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 provided, the description carries the full burden of behavioral disclosure. It states 'Live view' indicating a read operation, lists return fields, mentions the 50-trade history limit, and says 'Free — no auth required.' This provides useful context beyond what a schema would show, though it does not explicitly confirm side-effect-free behavior beyond the word 'view.'

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, front-loaded with the main purpose, and efficiently packs return field details into a parenthetical list. The 'Free — no auth required' addendum is a single short clause. Every sentence earns its place without unnecessary fluff.

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

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

Despite having no output schema, the description comprehensively details the return structure (active_trades, trade_history, daily_pnl, etc.) and access requirements. For a read-only, zero-parameter tool, this is complete and leaves no significant gaps for the agent to guess.

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

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

The tool has zero parameters, so there is nothing to explain. The baseline for 0 params is 4, and the description does not need to compensate for schema gaps since the schema is trivially 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 states the tool provides a 'Live view of all active and historical autopilot trades,' which is a specific verb+resource+scope combination. It distinguishes itself from siblings like autopilot_start/stop by focusing on viewing trades rather than starting or stopping the autopilot.

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

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

The description implies the tool is for retrieving trade data, but it does not explicitly mention when to use it over alternatives like autopilot_status. There is no exclusionary guidance, but the purpose is clear enough that an agent can infer usage context, making this an implied usage scenario rather than explicit 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?

No annotations are provided, so the description carries the full burden. It discloses significant behavioral traits: auto-fires Discord alerts, filters to only high-convergence symbols, includes options sniper output, and notes 'Free endpoint.' This goes beyond a simple scan description and warns about 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?

Four sentences, each adding distinct value: the action and universe, output criteria, extra output (options sniper), side effect (Discord alerts), and usage recommendation. No redundancy or filler; information is front-loaded.

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 parameters and no output schema, the description covers all essential aspects: what it scans, what it returns, side effects, usage role, and cost note. It is self-sufficient for an agent to decide when and how to invoke it.

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

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

There are zero parameters, and the schema coverage is 100% (vacuously). Per the rubric, baseline 4 is appropriate when no params exist. The description adds no parameter details because none are needed.

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?

Specific verb 'Scan' plus resource 'full Beastmode universe' with explicit tickers, and clear output criteria (HIGH_CONVERGENCE or BEASTMODE). This clearly distinguishes it from sibling tools like market_scan and convergence_check by specifying the exact universe and signal levels.

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 states 'Use this as the autonomous agent's primary market surveillance call,' providing clear context for when to use it. It does not explicitly name alternatives or when-not conditions, but the 'primary' phrasing implies precedence over other scan 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 provided, the description carries the full burden for behavioral disclosure. It discloses that the tool is free and includes grade and loyalty tier, which adds value. However, it does not disclose input validation requirements, data freshness, or any potential side effects, leaving some behavioral context missing.

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 exceptionally concise, consisting of three short sentences that front-load the core purpose. Each sentence adds meaningful information: the score itself, the included grade/loyalty tier, and the fact that it's free. No filler or repetition.

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

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

For a simple read-only tool with one parameter and no output schema, the description adequately covers the key return components: score range, grade, and loyalty tier. It does not detail exact response structure or edge cases, but given the low complexity and the high schema coverage, this 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 already covers the single parameter 'wallet' with a clear description, and schema coverage is 100%. The description adds no param-specific detail beyond restating the tool's scope ('for any XRPL wallet'), so it does not improve on the schema. Baseline of 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 clearly states the resource: a FICO-style 300-850 credit score for any XRPL wallet, including grade and loyalty tier. It distinguishes itself from sibling score tools by explicitly targeting XRPL wallets and the 'Agent Credit Bureau' concept. However, it lacks an explicit verb like 'get' or 'retrieve', relying on the noun phrase to convey 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?

The phrase 'for any XRPL wallet' implies a general usage context, but the description provides no explicit guidance on when to use this tool versus other score-related siblings (e.g., ccs_score, provider_score). No exclusions or alternative tool references are mentioned, so the usage guidance remains only implicit.

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 transparency burden. It discloses that the tool is free, is read-oriented ('Returns'), and that its content is optimized for AI agents to parse. It does not mention rate limits or authentication, but for a zero-parameter discovery endpoint with no side effects, 'Free' and 'Returns' adequately convey the behavioral 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 three sentences, front-loaded with the core purpose and followed by actionable guidance. Every sentence contributes value: what it returns, format note, cost/order-of-use. No filler or redundant restatement.

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 convey return-style information. It lists the major return contents (system description, verdict definitions, pricing, endpoint URLs, MCP tool list) and the usage context (use first). This is complete for a simple discovery tool with no parameters.

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 empty schema fully covers the input contract. The description adds no parameter-specific meaning because none is needed. Baseline for 0-parameter tools is 4, which is appropriate here.

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 ccs_info as a 'discovery endpoint' with a specific verb+resource: 'Returns full system description, how-it-works, verdict definitions, pricing, all endpoint URLs, and MCP tool list.' This distinguishes it from sibling tools like ccs_validate, ccs_score, and ccs_report which perform validation or scoring rather than system discovery.

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 usage guidance is provided: 'Use this first to understand the CCS system before calling ccs_validate.' The 'doorbell' metaphor and 'Free' signal that this is the entry point. This clearly instructs when to use ccs_info versus the ccs_validate alternative.

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 burden of behavioral disclosure. It transparently states that the tool is free, shows top 25 wallets, and includes a minimum validation requirement. It also reveals that the output includes validation history, pass rate, and reputation tier, providing useful context beyond the schema. However, it does not mention related aspects like whether the list updates in real time or if pagination is possible, but given the zero-parameter simplicity, this is acceptable.

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

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

The description is two sentences, front-loaded with the main purpose ('Top 25 most trusted wallets...'), and every sentence adds value: the first defines the result set and ranking metric, the second specifies the displayed fields and the minimum validation threshold, and ends with 'Free.' No 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 leaderboard tool with zero parameters, no output schema, and no annotations, the description is complete. It fully describes what the tool returns, the ranking criteria, the included data fields, and a qualifying condition. There is no missing critical information for an agent to decide whether to invoke it.

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

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

The input schema has zero parameters with 100% coverage (empty object), so there are no parameters to describe. Baseline for zero-parameter tools is 4, and the description aligns by not introducing unnecessary parameter information. It focuses on output content instead, which 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 clearly states the tool returns the 'Top 25 most trusted wallets' in the CCS network, ranked by CCS score, and lists the specific data shown (validation history, pass rate, reputation tier). This distinguishes it from sibling tools like ccs_score (individual score) and ccs_stats (aggregate stats) by emphasizing the leaderboard nature.

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

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

The description provides clear context on when to use this tool: when you need a ranked list of top wallets by trust or CCS score. It mentions the minimum validation threshold (3) and that it is free, which helps set expectations. However, it does not explicitly mention alternatives or when not to use it, but the context is sufficient for a simple query 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 discloses key behaviors: it penalizes the target wallet's CCS score by 3 points per confirmed report, requires a reporter CCS score >= 20 to prevent spam, and is free. This adds meaningful context beyond the schema, though it could further clarify the confirmation process.

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: three sentences covering purpose, effect, and eligibility/cost. No filler or redundant information, and it is front-loaded with the action.

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 primary action and effects but does not mention the return value or outcome of a submission (no output schema). It also does not explicitly link to ccs_validate for the content hash workflow, leaving some context incomplete.

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

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

The schema already describes all four parameters with 100% coverage, including the optional relationship between content_hash and target_wallet. The description adds no extra parameter details, so the baseline score of 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 clearly states the tool's purpose: flag a sender wallet or content hash as misinformation. It also specifies the consequence (penalty to CCS score) and is distinct from sibling tools like ccs_validate and ccs_score, which focus on validation and scoring rather than reporting.

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 gives clear usage context: it is for flagging misinformation, reporters must have CCS >= 20, and it is free. However, it does not explicitly state when not to use it or mention alternatives (e.g., ccs_validate for validation), 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?

No annotations are provided, so the description carries the full burden. It discloses the output fields (ccs_score, reputation_tier, validation history, block/pass rates) and states 'Free.' The verb 'Get' implies a read-only operation, though it does not explicitly state side effects (or lack thereof). It also does not mention error conditions or rate limits, but for a score lookup, this is reasonably transparent.

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

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

The description is three sentences with no waste. It front-loads the main purpose, then explains the blending logic, lists output fields, and ends with 'Free.' Each sentence adds value and the length is appropriate for 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 a single parameter and no output schema, the description provides a thorough overview: what the score represents, the output fields, and the cost. It fully equips the agent to understand the tool's return value and purpose. No significant gaps are apparent given the tool's simplicity.

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 one parameter 'wallet' with description 'XRPL classic address (rXXX),' giving 100% coverage. The tool description adds minimal parameter-specific context by saying 'any XRPL wallet,' but this is a restatement of the schema. Baseline 3 is appropriate since the schema handles the 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: 'Get the Cognitive Credit Score for any XRPL wallet.' It specifies the resource (XRPL wallet), the action (get score), and the composite nature (blends CCS trust ledger with Agent Credit Bureau score), which distinguishes it from siblings like bureau_public_score or ccs_report.

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

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

The description implies usage context by stating it returns a composite trust grade for any XRPL wallet, but it does not explicitly name alternatives or when not to use this tool. The mention of blending two scores helps differentiate it from sibling tools, but there is no direct 'when to use vs. alternatives' 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?

No annotations are present, so the description carries the burden of behavioral disclosure. It adds useful context (free, network-wide, lists the statistics) but does not explicitly state that the operation is read-only or describe the return format. For a stats tool this is acceptable but not fully transparent.

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 sentence that front-loads the core purpose, followed by a concise second sentence that adds context ('Free — GEO/SEO discovery signal'). Every word earns its place; there is no fluff or repetition.

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 adequately lists the metrics returned and hints at use cases. It could be more complete by specifying the response format (e.g., JSON object), but for a zero-parameter stats tool 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 tool has zero parameters and the schema is empty. The description focuses on the output content rather than inputs, which is appropriate. With 0 params, the baseline is 4, and the description meets it without needing to explain 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 provides 'Network-wide Cognitive Credit Swarms statistics' and enumerates specific metrics (total validations, block rate, trust rate, etc.). The 'Network-wide' scope differentiates it from sibling tools like ccs_info or ccs_leaderboard, 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 gives clear context: it's a 'Free — GEO/SEO discovery signal for agents indexing the trust network.' This implies when to use the tool, but does not explicitly mention alternatives or exclusions. Since the context is clear but no comparison to siblings is provided, 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 full burden of behavioral disclosure. It effectively communicates side effects (sender reputation tracking, blocked sender negative history), rate limits (3 calls/hour free), payment requirements (0.01 RLUSD via token), and what the call returns. This goes well beyond a minimal description.

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 front-loaded with the core purpose and output, followed by reputation mechanics and payment details. It is somewhat verbose but each section adds value. The inclusion of the Endpoint ID is a minor distraction and could be moved to schema or a separate field, keeping the description tighter.

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 an output schema and annotations, the description adequately covers all necessary information: what the tool does, return values, side effects, usage limits, and cost. It is comprehensive enough for an agent to decide when and how to 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?

Schema coverage is 100%, so baseline is 3. The description adds extra meaning to parameters: payment_token is linked to the paid tier and endpoint, sender_wallet is explained as enabling reputation tracking, and content types are expanded beyond the schema's 'text'. This additional context supports parameter understanding.

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 validates content ('Submit any text... receive a trust score, verdict, flag breakdown'), specifying input types and output format. It distinguishes itself from sibling tools like ccs_score and truth_verify by focusing on content trust validation and the specific verdict categories.

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

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

It provides clear context for use ('Used by agents to filter their information environment...'), explains the free tier and payment requirements, and describes the Micro-Attention Tax. It doesn't explicitly name alternatives or state when not to use it, but the intended usage scenario is well-defined.

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. It explains the trigger condition (daily P&L below AUTOPILOT_MAX_DAILY_LOSS_PCT), the action (re-arm), and the return fields. However, it does not disclose edge cases (e.g., what happens if the breaker is not tripped), state changes outside the breaker, or whether the call is idempotent. This is adequate but not fully transparent.

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

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

The description is concise and front-loaded: it states the main action first, then provides context, prerequisite, and return format. Each sentence adds value without redundancy. It is well-structured for quick consumption.

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 one-parameter tool without an output schema, the description is fairly complete: it explains the trigger mechanism, when to call, the required key, and the return fields. However, the ambiguity around X-Operator-Key versus operator_key and the lack of error-case information introduce slight gaps. Overall, it is adequate for the tool's simplicity.

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. The description mentions 'Requires X-Operator-Key,' which could be interpreted as a header, while the schema has an 'operator_key' property. This creates ambiguity and does not clarify the parameter's format or role. The parameter name is self-explanatory, but the description fails to link it clearly to the schema.

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

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

The description clearly states the tool's function: 'Reset the autopilot circuit breaker after a daily loss halt.' This provides a specific verb (reset) and resource (circuit breaker), distinguishing it from sibling autopilot tools (start, stop, status, trades) without explicitly naming them.

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

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

The description gives clear context on when to use: 'after a daily loss halt' and 'Call this to re-arm after reviewing trades and confirming resumption is safe.' It also mentions a prerequisite (Requires X-Operator-Key). No explicit exclusions or alternatives are provided, but the usage context is sufficient.

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 the async nature of the probe action, the score range, and that results include recent mentions and context. It also notes the tool is free. However, it does not mention any potential side effects or limitations beyond the probe timing.

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, front-loaded with the main purpose, and each sentence adds relevant detail (sources, score range, use case, pricing, probe behavior) without redundancy.

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

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

Given no output schema, the description adequately conveys the main return content (score, mentions, context) and covers the probe action's behavior. The history/status actions are left to the schema, which is acceptable given the schema's richness.

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

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

The input schema already documents all three parameters with 100% coverage, so the baseline is 3. The description adds value by describing the async behavior and 60-second result window for action='probe', which goes beyond the schema's enum 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 clearly states the tool retrieves citation authority scores for ScriptMasterLabs APIs, listing specific brands and data sources. It uses 'Get' as the verb and provides concrete details about the return value (0–100 score, mentions, context), making it distinct from sibling scoring 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?

It gives a specific use case ('gauge AI discoverability momentum') and explains when to trigger a fresh probe, but does not explicitly compare to alternatives or state when not to use the tool, which is a slight gap.

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 takes on the full burden of behavioral disclosure. It transparently discloses side effects: the Options Sniper scans Tradier for short-DTE options, and Discord alerts auto-fire on high-convergence signals. It also states the endpoint is free. However, behavioral traits like rate limits or the meaning of 'LIE_DETECTOR_ACTIVE' remain undisclosed, so it is not fully transparent.

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 with the primary purpose, then expands into engines, signal levels, and side effects. It is arguably longer than necessary, but each detail serves to clarify the tool's scope. The signal hierarchy and alert behavior are relevant and not redundant.

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 (five engines, options scanner, alerting, signal levels), the description covers a substantial portion of the context. However, it lacks an explanation of the 'LIE_DETECTOR_ACTIVE' level and does not specify the return format (though no output schema exists). It also omits any error conditions. Still, for a two-parameter tool, it is fairly comprehensive.

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 context about the sniper's behavior (high-leverage delta band) but does not explicitly map the parameter to that behavior. The symbol parameter's suitability for high-manipulation assets is only in the schema, not reinforced in the description. Since the schema covers semantics well, the description's incremental value is minimal.

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 specifies a precise action: running the full SML proprietary engine cascade and evaluating the Beastmode convergence gate. It names five dimension-specific engines and provides a signal hierarchy, making it unmistakable what the tool does. This clearly differentiates it from sibling scan tools like market_scan or beastmode_scan.

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

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

The description implies usage when you need a comprehensive convergence assessment across multiple market dimensions, but it does not explicitly compare against alternative tools or state when NOT to use it. There is no mention of scenarios where a simpler scan would suffice, so usage context remains implicit rather than prescriptive.

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 fully carries the behavioral disclosure burden. It discloses cost (0.10 RLUSD), per-symbol 60-second caching (back-to-back queries effectively free), typical response times (<2s cached, ~4s fresh), required auth (payment_token from verify_payment, agent_wallet), and the output composition (directive, confidence, regime label, price targets, engine breakdown). This is rich, operationally useful context beyond any 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?

Although the description is long, every sentence contributes value: differentiation, engine list, output components, usage trigger, pricing, caching, auth requirements, coverage, and performance. It is front-loaded with the core purpose, then details follow logically. No filler or tautology.

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 complex tool with no output schema, the description thoroughly covers inputs, cost model, cache behavior, response time, coverage limitations, and the full output structure (including per-engine breakdown). This gives an agent all necessary context to invoke and interpret results, except for rare error conditions, which are not critical for 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?

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning beyond the schema: it gives concrete symbol examples (SPY, QQQ, AAPL, NVDA, GME, AMC, IWM), explains the payment_token's origin and expiration ('JWT from verify_payment (1h TTL)' in schema, reinforced in description), and highlights the cost/cache tradeoff tied to parameters. This is more than the schema alone 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 leads with a specific verb+resource: 'Institutional-grade BUY/SELL/HOLD directive for US equity symbols.' It clearly states the tool's core function and differentiates from the sibling 'demo_council' by calling itself the 'production-grade upgrade,' making it easy to distinguish.

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 guidance: 'Call this when you need a high-conviction directional read before sizing or executing a position.' It also names the alternative (demo_council) and contrasts it ('IWM-only, 5-min cached, free'), and notes coverage boundaries ('US equities; crypto coverage in roadmap'), providing clear when-to-use and when-not-to-use 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 provided, the description carries the full burden. It discloses key behavioral traits: it is free, scoped to IWM, returns the 'Same JSON shape' as council_verdict, uses 'same engines', and has a '5-minute cache'. This is substantive context, though it doesn't describe the actual output fields or error behavior.

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

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

The description is two sentences, front-loaded with the core purpose, and every phrase adds value—free preview, scope, JSON shape, engines, cache, and cost comparison. No 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 zero-parameter preview tool, the description covers the essential aspects: what it does, its scope, its behavior (cache, JSON shape), and how it relates to the paid sibling tool. The lack of an output schema is mitigated by the 'Same JSON shape' statement, though specific output details remain 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?

The tool has zero parameters, and the schema confirms this with an empty properties object. The description adds relevant context about the tool's scope and cache, but since there are no parameters to explain, a baseline of 4 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 clearly identifies the tool as a 'Free preview of council_verdict' and specifies the exact scope ('scoped to IWM (Russell 2000 ETF)'). It distinguishes this from the sibling council_verdict by emphasizing the free preview nature and the single-ticker limitation.

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 tells the user when to use this tool: 'Use this to validate output quality and integration before paying 0.10 RLUSD per call on council_verdict for any symbol.' This clearly contrasts with the paid alternative and gives a concrete 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, the description carries the full burden. It discloses the free pricing, the limited response (latest value + date only), and the restricted whitelist. However, it does not mention error behavior for invalid series_id or rate limits, though these are minor for a simple preview 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 description is two sentences, front-loaded with the key facts ('Free. Latest value + date only'), and every sentence provides useful information without redundancy.

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

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

For a one-parameter tool with no output schema and no annotations, the description fully covers the essential contract: what it returns, the limitations, the cost, and the path for expanded needs. No significant information is missing.

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

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

The schema already documents the single parameter with 100% coverage, listing the exact allowed values. The description reinforces the whitelist and adds context about the alternative for other series, but this is supplementary rather than essential.

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 returns the latest value and date for a small whitelist of FRED series, with no metadata. It names the exact series and distinguishes from the sibling fred_series tool, which is the paid full-metadata alternative.

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 directs users to fred_series for any series_id outside the whitelist or when full metadata is needed. This provides clear when-to-use and when-not-to-use guidance, plus a named alternative.

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 discloses the cost, the return payload (latest observation plus metadata), and error cases (missing FRED_API_KEY or no data). It also states the requirement for payment_token and agent_wallet, adding useful context beyond 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 description is compact yet information-dense, starting with cost, then what it returns, examples, error behavior, and required parameters. No unnecessary 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?

Given there is no output schema, the description explains what is returned and under what conditions errors occur. It covers cost, prerequisites, and the API key requirement, making it complete for an AI agent to invoke 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 input schema only describes series_id. The description adds meaningful context by explaining that payment_token comes from verify_payment and agent_wallet must be passed, and provides series_id examples. This compensates for the low 33% schema coverage.

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

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

The description clearly states the tool fetches the latest real observation and metadata for any FRED series, naming specific examples like CPIAUCSL and UNRATE. It identifies the resource (FRED) and the action (retrieve series data), but does not distinguish itself from the sibling tool fred_preview.

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 clear usage context: use for any FRED series, with cost noted as 0.01 RLUSD, and instructs to pass payment_token from verify_payment plus agent_wallet. It also notes error behavior when API key is missing, but does not mention alternatives or 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 must carry the transparency burden. 'Browse' implies a read-only operation and 'Free' indicates no cost, but it does not explicitly state non-mutating behavior, authentication requirements, or side effects. The mention of 'open' positions conflicts with the status filter allowing SETTLED/EXPIRED, which is not clarified.

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 four short sentences, each providing distinct information: purpose, filters, output fields, and cost. No filler or redundancy.

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

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

The description covers the essentials but leaves gaps: it doesn't explain the status/bias enums, the meaning of 'open' versus the status filter, the return format, or pagination behavior. Given no output schema and no annotations, this description is adequate but not comprehensive for a complex browsing 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 description coverage is only 25% (limit), so the description must compensate. It does identify symbol, status, and bias as filters, adding some context, but it does not explain the enum values or the differences between OPEN and ACTIVE. The description adds partial value but leaves the enums ambiguous.

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?

Description clearly states the tool browses open Signal Futures positions with a specific verb and resource, and immediately distinguishes itself from siblings like futures_create, futures_take, and futures_leaderboard. It also lists the available filters and output fields, 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?

Usage is implied: use this to browse positions. However, it does not explicitly state when to prefer it over alternatives or when not to use it. The description notes filters but gives no exclusions or alternative tool references.

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 disclosure burden. It reveals key behaviors: auto-settlement on real verdict, 95% pot distribution to winner, zero custody (wallets settle direct), and zero cost to create. It does not disclose loss risk or prerequisites, but the provided behavioral details go well beyond a simple 'create' description.

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 four sentences long, front-loaded with the action, and every sentence adds value (creation, counterparty, settlement, pot split, custody, cost). There is no redundant or filler 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 complex tool with no output schema and no annotations, the description explains the core domain mechanics well: what the prediction is about, how the pot is split, and the settlement/custody model. However, it omits details about session, ttl_hours, and what happens if no taker appears, leaving some operational gaps. Overall fairly complete for the main 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 description coverage is 71%, so the baseline is 3. The description reinforces the meaning of key parameters (e.g., 'stake RLUSD' for stake_rlusd, 'predict what the NEXT verdict will be' for predicted_bias) but adds little beyond the schema's existing field descriptions. Parameters like session and ttl_hours are not elaborated in the description, so the schema remains the primary source.

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 action ('Open a Signal Futures position'), the resource (futures position on a symbol), and the purpose (predicting the next SqueezeOS council verdict and staking RLUSD). It distinguishes itself from sibling tools like futures_take (taker side) and futures_browse by focusing on position creation.

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

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

The description provides clear context for when to use this tool: when you want to create a position as the 'creator' by predicting a verdict. It mentions that 'Taker bets the opposite side,' implying an alternative tool for counterparties, but does not explicitly name futures_take or provide when-not-to-use guidance. This is clear context but lacks explicit 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 transparency burden. It discloses output metrics and notes 'Free' (cost-free), but does not explicitly state read-only behavior, data freshness, or ranking tie-breakers. It provides some context but leaves room for more.

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: three short sentences conveying purpose, output fields, and cost status. Every word earns its place with no fluff or repetition.

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 tool with one optional parameter and no output schema, the description covers the core purpose and output fields. It lacks minor details like data source or tie-breaker rules, but these are not critical for basic understanding.

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 only parameter 'limit' is fully described in the schema (default 20, max 100), and schema coverage is 100%, so the baseline is 3. The description's mention of 'Top predictors' implies ranking context but does not add detail about the parameter itself.

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 it returns a leaderboard of top Signal Futures predictors ranked by wins, with specific metrics like win rate, PnL, and total staked. This distinguishes it from sibling tools like futures_browse or futures_create, which imply different actions.

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

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

No explicit when/when-not guidance or alternatives are mentioned, but the purpose is clear enough that usage is implied: use this to view top futures predictors. Sibling tools suggest distinct actions, so the role is reasonably inferred, but exclusions are not stated.

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 discloses that stakes are locked immediately, settlement occurs on the next council verdict, the tool is free, and the win condition is based on mismatch with the creator's prediction. This is substantial behavioral context, though it omits details like reversal/cancellation conditions.

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 four short, front-loaded sentences with no filler. Every sentence adds value: what it does, how you win, when stakes lock, when it settles, and cost.

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 tool is conceptually simple with only two parameters and no output schema. The description explains purpose, settlement, and cost. It could mention the return value or failure modes, but it is sufficiently complete for an agent to select and invoke 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 coverage is 100%, with both parameters already described as 'UUID from futures_browse' and 'Your XRPL wallet.' The description does not add additional parameter-level details, so the baseline score of 3 is appropriate since 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 starts with a specific verb 'Take the opposite side of an open Signal Futures position,' clearly distinguishing this from futures_create and futures_browse. It also states the win condition and settlement mechanism, 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 clearly implies use when you want to bet against a creator's prediction on a Signal Futures position, with context on settlement. However, it does not explicitly exclude alternatives or mention when not to use it, though the sibling tools make the context fairly clear.

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. It discloses the return fields (XRPL destination address, amount in RLUSD, memo_hex) and that it is free. However, it doesn't mention potential side effects, idempotency, or error cases, leaving some ambiguity about the operation's behavior.

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

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

Three short sentences, front-loaded with the primary action, followed by return details and a workflow instruction. No filler or redundancy.

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

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

For a simple one-parameter tool, the description covers purpose, return format, cost, and next steps. The absence of an output schema is mitigated by listing the returned fields. Minor details like error behavior are omitted but the core context is 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 sole parameter endpoint_id is fully described in the schema as 'UUID of the endpoint to pay for' with 100% coverage. The description adds little beyond the schema, merely saying 'any SqueezeOS endpoint'.

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

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

The description uses a specific verb 'Request' with a clear resource ('payment invoice for any SqueezeOS endpoint'). It also distinguishes itself from sibling verify_payment by explicitly instructing to call that tool afterward, making its role clear.

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 clear context for when to use (to get an invoice) and includes workflow guidance ('Pay on XRPL then call verify_payment'). However, it doesn't explicitly state when not to use or mention alternative tools beyond verify_payment as a follow-up.

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. It discloses 'Free' and implies a read-only operation via 'Browse', but does not mention auth requirements, rate limits, or output format. This is acceptable for a simple browse tool but lacks depth.

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

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

The description is three short sentences, front-loaded with the main purpose, and contains no filler. It efficiently conveys scope, filtering, and cost.

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 browse tool with optional parameters and no output schema, the description is minimally adequate. It does not explicitly state what the return value is (a list of jobs) or any prerequisites, but 'browse' implies it. More detail 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?

Schema coverage is 0% and the description only lists 'type, symbol, or min bounty' as filters without explaining their meaning or allowed values. 'type' and 'symbol' are ambiguous, and the description does not compensate for the lack 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 clearly states the action ('Browse') and specific resource ('open agent hiring jobs'), and it distinguishes from the sibling 'hiring_post_job' by focusing on browsing rather than posting. The filtering options and 'Free' add useful context.

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

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

The description implies usage for browsing jobs and filtering, but does not explicitly state when to use this tool over alternatives like 'hiring_post_job' or other browse tools. It gives no exclusions or alternative 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?

No annotations exist, so the description carries the transparency burden. It adds useful context about the direct XRPL payment mechanism and that posting is free. However, it does not explain job lifecycle, response format, or whether posting is reversible, leaving significant behavioral gaps.

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 exceptionally concise, packaging purpose, payment model, and cost in two sentences. Every word earns its place; no redundancy. It is front-loaded with the core action.

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 7 parameters, no output schema, and no annotations, the description is severely incomplete. It omits required workflow context (what happens after posting, how matches are made, how response is used) and parameter guidance. While it covers the basics, the agent would likely need additional context to invoke 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 coverage is only 14%, so the description must compensate. It mentions bounty and wallet concepts but does not explain the seven parameters, the difference between wallet and payment_wallet, job_type enum values, or deadline constraints. This leaves agents under-equipped to construct a valid request.

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?

Clearly states the action (post) and object (analysis job) with a specific audience (other agents). It distinguishes from browse-type siblings like hiring_browse_jobs. The mention of bounty payment and free posting adds clarity, though 'analysis job' is slightly narrower than the job_type enum's full range.

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?

Implies usage—when you need a job fulfilled by other agents—but does not explicitly contrast with alternatives like hiring_browse_jobs or futures tools. No when-not-to-use guidance is given. The payment details provide context but not decision 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?

With no annotations provided, the description carries the full burden and does so richly. It discloses the proprietary nature, cost, five independent analysts, the five computed factors, output structure (mandatory action, rationale, vehicle, invalidation, review trigger, per-analyst pressure), and that internal AMM invariant parameters are redacted. This is exceptional 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 long but every sentence adds value: purpose, methodology, output, cost, redaction, and usage guidance. It's front-loaded with the core purpose and uses a numbered list for the five analysts. Slightly verbose but highly informative.

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 what the tool returns, and it does: mandatory action, rationale, vehicle, invalidation condition, review trigger, and per-analyst pressure. It also covers cost, redaction, and prerequisites, making it complete for a complex 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% with descriptions for all three parameters. The description adds minor context by naming the payment source (verify_payment) and reinforcing the wallet requirement, but mostly repeats what the schema already provides. Baseline of 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 clearly states the tool's purpose: 'Resolves what action the market is FORCED to take, not what it is predicted to do.' It uses specific verbs and distinguishes itself from predictors, and the sibling iam_truth is explicitly mentioned as a free preview alternative.

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 to use iam_truth (free) to preview before paying, and mentions that payment_token from verify_payment plus agent_wallet must be passed. This gives clear context on when to use this tool and the prerequisite steps, though it doesn't explicitly list 'when not to use' scenarios beyond pointing to iam_truth.

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 transparency burden. It discloses the neutral, non-actionable nature, lists exactly what is returned (all five pressure components, Directional Bias always NONE, and Time Window states), and notes it is a 'Free endpoint'. This gives a comprehensive picture of the tool's behavior.

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

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

The description is dense but efficient, packing the core purpose, key behavioral constraints, and return fields into a single paragraph. It front-loads the tool's name and primary distinction. Minor structural improvements (e.g., splitting into sentences) could enhance readability, but it is not overly verbose.

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 simplicity (one parameter, no output schema), the description fully covers what the tool does and what it returns. It enumerates all output fields and explains the tool's neutral philosophy, making it complete for an AI agent to understand and invoke 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 coverage is 100% for the single parameter 'symbol', with the description 'US equity ticker'. The tool description adds no additional meaning beyond restating that it requires a symbol, so the baseline score of 3 applies.

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

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

The description clearly states the tool's purpose: it returns a neutral obligation state for a symbol, breaking down into specific pressure components. It explicitly distinguishes itself from action-resolving tools by stating 'No action resolution' and 'before direction is forced', which differentiates it from siblings like iam_resolve.

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

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

The description provides clear context for when to use the tool: when you need the raw, neutral obligation state before direction is forced. It notes the tool is 'strictly neutral' and 'free', but does not explicitly name alternative tools or state exclusions, so it falls short of a full 5.

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

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

No annotations are provided, so the description must carry the burden. It discloses the cost (0.03 RLUSD), which is a useful behavioral detail. However, it does not describe the output format, whether the operation is read-only, or any side effects, leaving gaps for the agent.

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

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

The description is two concise, front-loaded sentences with no filler. Every word adds value, and the key features and cost are stated directly.

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 sparse annotations, the description should explain what the scanner returns and how parameters work. It does neither, making it incomplete for an agent to use without additional 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 description coverage is 0%, and the description does not explain the two parameters (agent_wallet, payment_token) or their roles. The agent must guess their meaning from names alone, which is insufficient for correct invocation.

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 scanner for IWM zero-day-to-expiry options, listing specific metrics it scores (delta/gamma, gamma flip level, max pain, 30-day realized vol). This goes beyond a vague 'scanner' and distinguishes it from sibling tools like market_scan or options_intelligence.

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

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

The description provides clear context: this is for IWM 0DTE options analysis. It does not explicitly state when to use it over alternatives or when not to use it, but the specificity makes the intended use case evident.

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 discloses cost (0.04 RLUSD), automatic Discord alerts on perfect bullish/bearish hits, and payment dependencies. It also explains the squeeze_alert logic, giving a good picture of side effects and 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 informative but verbose, with repeated mentions of cost and max 50 symbols. It is structured but includes some marketing-like language (e.g., 'full institutional highway') that adds noise. Trimming would improve conciseness.

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?

Despite no output schema, the description explains the three macro states and the squeeze_alert condition in detail, compensating well. It also covers cost and payment requirements. Missing an explicit return format example, but the context 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 coverage is 100%, so the baseline is 3. The description adds clarity on the payment flow (pass payment_token from verify_payment plus agent_wallet) but the schema already documents each parameter well. No significant additional 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 clearly states the tool's function: a 5-layer EMA structural alignment engine that computes EMA 30/60/90/120/741 on daily closes for US equity tickers and returns one of three macro states. It is highly specific and distinct from sibling tools like sovereign_741.

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

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

The description provides clear usage context, including that tickers are dynamic, max 50 symbols per call, and payment requirements. It does not explicitly compare to alternatives or state when not to use it, but the context is strong enough for an agent to select it appropriately.

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. It discloses that the operation is a browse (likely read-only) and that it is free, which are useful traits. But it does not describe the return format, pagination, authentication requirements, or behavior when no filters are applied.

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: three short sentences with no filler. It covers purpose, filter options, and cost in a highly efficient structure that front-loads the essential 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 simple browse tool, the description covers the main points: what it does, how to filter, and that it is free. However, with no output schema or annotations, it does not explain the return value (e.g., list of listings with price, symbol, bias) or any limitations such as result limits. This leaves some gaps but is mostly 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 tells us that symbol and bias are filters, which is important, but it does not add meaning beyond the schema's enum for bias or clarify symbol format. The parameter names are fairly self-explanatory, but the description adds only minimal value over the schema.

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

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

The description clearly states that the tool browses peer signal marketplace listings and supports filtering by symbol or bias. The verb 'browse' distinguishes it from sibling tools like marketplace_list_signal and marketplace_read_signal, which likely have different functions such as listing or reading individual signals.

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

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

The description implies usage for exploring marketplace listings, and the word 'Free' signals that it can be used without cost. However, it does not explicitly state when to use this tool over alternatives or provide exclusions, leaving the usage context solely implied.

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 behavioral disclosure. It does add value by specifying the cost to buyers (0.02 RLUSD), the credit score reward for sellers (+2 per sale), and that posting is free. However, it does not disclose side effects such as whether posting requires a wallet balance, how the listing is created, or any moderation process. This is a partial disclosure, not a full one.

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

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

The description is three short, purposeful sentences. It front-loads the purpose, then adds economic details and a cost note. Every sentence earns its place, with no redundant or vague phrasing.

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 (9 parameters, 5 required) and absence of annotations or output schema, this description is insufficient. It does not explain the required parameters, the process after posting, or potential errors. The economic context is helpful but does not complete the picture for an agent to invoke 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 0%, so the description should compensate by explaining parameter meanings. It only hints at 'thesis' as the content buyers read, but fails to clarify 'wallet', 'symbol', 'bias', 'confidence', 'stop', 'entry', 'target', and 'signal_type'. The schema provides some self-descriptive hints (e.g., bias enum), but the description adds negligible parameter guidance.

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

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

The description opens with a specific verb and resource: 'Post your own analysis signal to the marketplace.' This clearly distinguishes the tool from sibling tools like marketplace_browse (browsing) and marketplace_read_signal (reading others' signals). It also states the economic model (buyers pay, sellers earn credit), reinforcing its 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?

The description clearly implies when to use this tool: when you have an analysis signal to post for sale. The context of marketplace interactions is evident from sibling names, but it does not explicitly state exclusions or alternatives (e.g., 'use marketplace_read_signal to read others'). Still, the context is clear enough for agents to differentiate.

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 must disclose behavioral traits. It does disclose the cost (0.02 RLUSD) and the return content, which are valuable. However, it does not mention prerequisites, auth requirements, or whether the cost is refundable. The cost disclosure is a strong point, warranting a 4 rather than a 3, but it is not fully comprehensive.

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 exceptionally concise, comprising three short sentences that each add meaningful information: the action, the return data, and the cost. It is front-loaded with the purpose and avoids any fluff. No unnecessary words or repetition.

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?

While the description covers the core purpose, cost, and return values, it lacks important contextual details such as the role of agent_wallet and payment_token, whether prior purchase is required, and the exact output structure (no output schema exists). Given the simple nature of the tool and the cost disclosure, it is minimally viable but has clear gaps in payment workflow and parameter semantics.

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 description coverage is only 33%, with agent_wallet and payment_token lacking any description. The tool description does not clarify these parameters; it only mentions cost, which indirectly relates to payment_token but does not explain its purpose or usage. The description fails to compensate for the low schema coverage, leaving two of three parameters ambiguous.

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

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

The description clearly states the tool's function with a specific verb ('Read') and resource ('full thesis for a marketplace signal listing'), and distinguishes it from sibling tools like marketplace_browse and signal_preview by emphasizing 'full thesis'. It also lists the returned data (entry, target, stop, seller reputation), making the purpose explicit and 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 implies the tool is for obtaining the full thesis rather than a preview or browse, but it does not explicitly state when to use it vs. alternatives or mention any exclusions. It lacks references to sibling tools or usage context, such as 'use after browsing' or 'only for purchased signals', so guidance is implicit 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?

The description discloses the cost (0.05 RLUSD) and output (ranked setups and options picks), which is useful. However, with no annotations, it carries the full burden for behavioral transparency. It does not explain payment mechanics, failure behavior, or any side effects, leaving gaps for a tool that charges a fee.

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, well-structured sentence that front-loads the core purpose, then includes output and cost. Every clause earns its place with no filler, making it highly concise and efficient.

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 lack of annotations and output schema, the description should provide more context. It includes the cost and high-level output, but leaves out parameter usage, usage guidance, and explanation of key terms like '8-module score' and 'grade-A options picks'. For an agent to invoke the tool correctly, critical information is missing.

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

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

Both parameters (agent_wallet, payment_token) have zero schema description coverage, and the description does not explain their purpose or relationship to the cost. It mentions 'Cost: 0.05 RLUSD' but fails to indicate which parameter is the wallet address or payment token, or what values are expected. This is a critical gap.

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 it is a scanner for the full $1-$50 equity universe, returning setups ranked by an 8-module score and grade-A options picks. The verb and resource are specific, but it does not explicitly differentiate from sibling scan tools like beastmode_scan or macro_741_scan, relying on unique terms like 'squeeze' and '8-module score'.

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 on when to use this tool versus alternatives. There is no mention of exclusions, prerequisites, or comparison to sibling scanners. The only implied usage is the 'full universe' scope, but it is not actionable enough for an agent to decide between this and other scan 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 full burden of behavioral disclosure. It reveals the cost (0.01 RLUSD), the non-semantic/non-vector nature (no embedding model), the recency ranking, and the explicit match_method field in the response. It also discloses the payment requirement, providing a thorough behavioral 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 short and front-loaded, starting with the core identity ('Memory Graph') and cost, then the search method, then a critical usage note. Every sentence adds value without redundancy or excessive length.

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 7 parameters and no output schema, the description covers the essential aspects: purpose, method, cost, payment prerequisite, and a hint about the response format. It lacks examples or details on limit and type behavior, but for a recall tool the overall context is sufficiently complete to guide 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 coverage is only 14%, so the description compensates well. It explains the meaning of query and tags (literal keyword/tag search), clarifies payment_token and agent_wallet as payment-related parameters, and implies agent_id via 'agent's own stored memories.' However, limit and type are not explicitly described, leaving a small gap.

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 literal keyword/tag search over an agent's own stored memories, ranked by recency. It specifies the resource (agent memories), the action (recall via keyword/tag), and explicitly distinguishes it from semantic or vector search, which differentiates it from sibling tools like semantic_gaps or memory_store.

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

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

The description provides clear usage context: use this for literal keyword/tag recall and not for semantic search. It also includes the prerequisite that payment_token and agent_wallet must be passed, and notes the cost. However, it does not explicitly name alternative tools or describe when not to use it beyond the semantic exclusion.

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 for behavioral disclosure. It adds useful context (free to call, real count, and backend identification) but does not describe side effects, error conditions, or how the output is structured. It provides some transparency beyond the name but is not comprehensive.

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, concise sentence that immediately states the tool's purpose and key details. It is front-loaded with 'Free' and then the core function, with no 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?

Given the tool has one parameter and no output schema, the description provides the main functionality and output highlights (count by type, active backend). However, it lacks detail on the return format, potential errors, or any prerequisites, making it minimally adequate 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 coverage is 0%, so the description must compensate. While the phrase 'an agent's stored memories' implies the agent_id parameter, the parameter name, format, and requirements are not explicitly described, leaving room for misinterpretation.

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 it provides a real count of an agent's stored memories by type and identifies the active storage backend, making the tool's function specific and distinct from memory_recall and memory_store. However, it does not explicitly name alternatives, so it stops short of full sibling differentiation.

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 versus alternatives. The description gives no context about prerequisites, use cases, or exclusions, leaving the agent to infer usage from the purpose alone.

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 explicitly states that memory persists across sessions, that provenance is kept exactly as submitted, and that the tool never invents or upgrades confidence scores. It also discloses the cost and the requirement for payment_token. These are valuable behavioral details beyond what the schema shows.

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

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

The description is three sentences and front-loaded with the tool's identity ('Memory Graph'), followed by cost and the core behavior. Every sentence adds value without redundancy, and the structure is easy to scan.

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 tool has moderate complexity with 7 parameters, nested provenance, and a payment flow. The description covers the core storage behavior and prerequisites, but omits details like return values, error handling, or what happens on duplicate memories. Given the lack of output schema and the tool's complexity, the description could be more thorough to be 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 compensate. It does explain the critical parameters: provenance.confidence is required, payment_token and agent_wallet must be passed, and indirectly content/agent_id via 'agent memory'. However, it does not clarify the meaning of tags, type, source_id, or source_type. This gives partial but not complete 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: 'Persists an agent memory in Redis (durable across sessions)'. The verb 'persists' and resource 'agent memory' make the action unambiguous. It also distinguishes itself from sibling tools like memory_recall by indicating a write operation, whereas memory_recall presumably reads.

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

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

The description provides clear usage context by noting prerequisites: 'pass payment_token from verify_payment plus agent_wallet.' It also mentions that provenance.confidence is required. However, it does not explicitly contrast with alternatives like memory_recall or memory_stats, though the nature of the tool implies when it should be used. This earns a 4 rather than 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 burden. It clearly states the tool scans files and returns ranked issues with fix advice, implying a read-only analysis. It also notes the tool is 'Free,' a behavioral detail. No mutation or side effects are suggested.

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 four short sentences, front-loaded with purpose ('Analyze'), followed by scan targets, output, and usage timing. The single extra 'Free' is minor and does not detract from overall efficiency.

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 covers what, how, output, and when to use. It doesn't detail the format of 'ranked issues,' but that's acceptable given the tool's simplicity and lack of parameters.

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 an empty schema, making schema coverage 100%. The description adds no parameter info because none are necessary; the baseline for zero-parameter tools is 4, and the description does not need to compensate.

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

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

The description uses a specific verb 'Analyze' with a clear resource ('ScriptMasterLabs API descriptions') and scope ('AI-discoverability weaknesses'). It also specifies scan targets (llms.txt, .well-known/mcp.json) and output, making it distinct from any sibling 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?

It provides a clear trigger: 'Run this before updating discovery manifests.' This tells the agent when to use it. It doesn't explicitly mention alternatives or when-not-to-use, but no closely related sibling tool exists, so the context is sufficient.

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 transparently states the cost (0.05 RLUSD), which is a significant behavioral trait, and outlines the data content. However, it does not explicitly state whether the operation is read-only, requires authentication beyond the wallet/token, or has any side effects. Given the paid nature and data delivery, a 3 is appropriate.

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

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

The description is concise and front-loaded. The first phrase 'Institutional options flow' immediately establishes the topic, followed by a compact list of features and the cost note. Every piece of text earns its place with no filler or repetition.

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 core data content (sweeps, blocks, GEX, etc.) and the cost, which is valuable. However, there is no output schema, so the description should clarify what the return format looks like (e.g., a report object, time series, etc.). It also does not explain how the payment is processed. These gaps make it incomplete for a fully self-contained tool description.

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 0% description coverage, so the description must compensate for the parameters. The mention of 'Cost: 0.05 RLUSD' vaguely relates to the payment_token and agent_wallet parameters, but it does not explicitly explain that agent_wallet is the paying wallet or what payment_token should be. This leaves the agent to infer parameter meanings from names alone, which is insufficient.

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 defines the tool's purpose: providing institutional options flow data including sweep detection, whale blocks, and unusual volume, along with metrics like net delta, GEX, put/call ratios, and max pain. This is specific and distinguishes it from sibling tools like 'market_scan' or 'rwa_intelligence'. However, it lacks an explicit action verb (e.g., 'get', 'view'), so it's not a perfect 5.

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

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

No guidance is provided on when to use this tool versus alternatives. It states what it does (institutional options flow) and its cost, but does not mention prerequisites, exclusions, or alternative tools for different scenarios. The intended use case is only implicit from the content.

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. It discloses that the tool is free ('No payment required'), returns specific data types (feed names, descriptions, counts, poll intervals, pricing), and lists available feeds. It avoids any misleading hints and is transparent about its read-only nature despite lacking explicit safety 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 three sentences and front-loaded with the core purpose. It lists returns and feeds efficiently, then gives a usage directive. Every sentence adds value with no redundancy, making it concise and well-structured.

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

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

Given the tool's simplicity (0 params, no output schema, no annotations), the description covers the essential context: what it does, what data it returns, which feeds are available, and when to use it. It provides a complete picture for an agent to select and invoke 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 0 parameters, and the schema is an empty object. Per the rubric, a 0-param tool gets a baseline of 4. The description does not need to explain parameters; it instead explains the output and usage, which 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 clearly states the tool is a 'Free catalog of all available Real-World Data Oracle feeds' and enumerates specific feeds (sec_8k, sec_s1, fda, patents). It distinguishes itself from sibling oracle_query by positioning itself as a pre-query catalog, covering purpose and differentiation.

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 instructs when to use it: 'Use this before calling oracle_query to see what data is available and how many events are buffered.' This provides clear contextual guidance and names the alternative tool, satisfying the when-to-use requirement.

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 discloses cost (0.02 RLUSD), payment authentication via verify_payment, output format (JSON with timestamps, source URLs), and latency advantage. It does not cover error handling or rate limits, but for a retrieval tool this is a strong disclosure.

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 front-loaded with cost and purpose, then details. Each sentence provides useful information, though the cost is mentioned twice ('Premium (0.02 RLUSD)' and 'Cost: 0.02 RLUSD per call.'). Slight redundancy keeps it from a 5.

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 tool's purpose, data scope, output format, parameter usage hints, cost, and auth requirement. It is comprehensive for a 6-parameter read-only query tool with no output schema.

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

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

The schema covers all 6 parameters (100%), so baseline is 3. The description adds semantics for the feed keys, mapping them to regulatory events (e.g., sec_8k (8-K material events)), and clarifies the purpose of since_ts. This adds value beyond the schema.

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

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

The description clearly states the tool's function: 'search or retrieve events from the Real-World Data Oracle' and enumerates four regulatory feeds (sec_8k, sec_s1, fda, patents). It uses a specific verb and resource, and explains the data domains. However, it does not explicitly differentiate from the sibling tool 'oracle_feeds', so it falls short of a 5.

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 context for when the tool is valuable, noting 'Sub-second delivery vs Bloomberg's 5–10 minute lag' and 'agents that catch the 8-K or FDA approval first win the trade.' It doesn't explicitly name alternatives or exclusions, but the context is clear that this is for real-time regulatory events.

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 fully carries behavioral disclosure. It specifies the server-side sanitization policy (stripping price levels, EMA values, raw indicators) and lists exactly which fields are delivered. It also reveals the fallback to a shared channel and the SLACK_WEBHOOK_URL requirement, providing rich transparency beyond 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 description is three sentences: purpose, sanitization policy, and webhook configuration. It is well-structured and front-loaded, but the trailing 'Free' adds negligible value and could be omitted.

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 9 parameters and no output schema, the description covers essential operational context: sanitization, webhook targeting, and environment variable fallback. It does not address error handling or return format, but these are less critical for a posting 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?

The description clarifies the webhook_url parameter's behavior (custom vs. shared channel) and enumerates the sanitized output fields (direction labels, confidence, regime, risk level, thesis), mapping to schema parameters. However, it does not add detail for symbol, session, or actionable, which the schema partially describes.

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: 'Post a sanitized market signal brief to Slack via incoming webhook.' It specifies the verb (post), resource (Slack), and key differentiator (sanitization), distinguishing it from all sibling tools, none of which target Slack.

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 gives explicit operation guidance: pass webhook_url for a custom channel or omit it for the shared SML channel, with the env var requirement noted. It implies the context for use (posting a market signal brief) but does not explicitly state when not to use it or compare to 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 provided, the description carries the transparency burden. It discloses the return payload, the deliberate omission of internal parameters, the significance of combined_score, and the meaning of consensus categories, giving a clear behavioral model. It does not mention data freshness or error behavior, but that is acceptable for a signal 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 description is dense but well-structured, front-loading the tool's identity and vision before listing engines, consensus levels, output components, and downstream integration. Every sentence contributes useful information, with only the trailing 'Free.' being a minor extra.

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 (three engines, multiple consensus levels) and the absence of an output schema, the description covers purpose, outputs, and its role with council_verdict comprehensively. It could add explicit guidance on when to prefer this tool over siblings or how to interpret each engine block, but overall it is a complete high-level picture.

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 `symbol` parameter is already fully documented in the schema as 'US equity ticker'. The description provides no additional parameter semantics beyond the schema, so the baseline score of 3 applies.

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

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

The description clearly identifies the tool as a proprietary EMA suite that evaluates three market dimensions to produce a consensus signal. It names specific engines, enumerates consensus levels, and distinguishes itself from siblings by noting it feeds council_verdict confidence.

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

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

The description implies when to use the tool ('evaluated together for high-conviction consensus') and mentions its role relative to council_verdict, but it does not explicitly state when to use this tool versus alternatives like signal_history, signal_preview, or convergence_check.

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 for behavioral disclosure. It mentions 'live AI agent traffic' and 'Free,' and lists returned components (volume, diversity, conversion, repeat rate) plus breakdown/trend. However, it omits details like whether it modifies anything, authentication needs, rate limits, or the structure of the response. It gives some context but not comprehensive 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 relatively concise and front-loaded with the core purpose. The trademark 'ARGUS AgentPageRank™' and the trailing 'Free' add a promotional tone but do not significantly hurt clarity. Each sentence contributes useful information overall, so it earns a 4 rather than 5.

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 tool is simple (2 optional params, no output schema), and the description covers the main score and components, plus breakdown and trend. However, it omits the 'leaderboard' view from the return types, and does not explain the structure of the returned data beyond the component names. Given the schema covers parameters, this is a moderate gap, so 3 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 schema provides 100% coverage for both parameters ('view' and 'hours') with descriptions and an enum. The description adds no extra parameter meaning beyond the schema, so the baseline score of 3 is appropriate. It does not confuse or contradict the schema.

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

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

The description clearly identifies the tool's function: 'Get the SqueezeOS API provider quality score (0–850) from live AI agent traffic.' It specifies the resource (SqueezeOS provider score) and verbs (Get), and distinguishes it from sibling score tools by describing unique components (volume, diversity, conversion, repeat rate). The mention of 'ARGUS AgentPageRank™' further differentiates it.

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-case guidance: 'Use this to benchmark provider authority before integrating or citing SqueezeOS.' This tells the agent when to apply the tool. It does not explicitly name alternatives or exclusions, but the context is clear enough given the unique 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?

No annotations are provided, so the description carries the full disclosure burden. It goes beyond the schema by revealing data sources (Reddit/HN), the ability to trigger scans via action='scan', the output nature (ranked topics), and the cost model ('Free'). This is substantial contextual disclosure, though it omits rate limits or potential side effects of triggering a scan.

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 five sentences, front-loaded with the core purpose, and each sentence adds useful detail. Even the 'Free' note at the end is concise and relevant. There is no fluff or redundancy, making it highly efficient in size.

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 primary 'gaps' behavior and the 'scan' action well, but with no output schema, it falls short on describing return structures for all enum actions ('raw' and 'status'). The overall return format is only described at a high level ('ranked topics'), leaving operational details undocumented for non-default modes.

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% (all parameters described). The description adds value by providing a concrete usage example ('Trigger a fresh scan with action='scan'') and clarifies the default mode (gaps=leaderboard) implicitly through the main output explanation. This operational guidance enhances the parameter understanding 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 uses specific action verbs ('Discover', 'Scans', 'Returns') and clearly identifies the resource (unmet API demand signals from Reddit/HN). It distinguishes itself from sibling tools by focusing on product opportunity identification via community demand, a unique niche among the listed scanners.

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 clear use context: 'Use this to identify new product opportunities.' It implies when to choose this tool (when exploring new API product gaps) but does not explicitly mention when not to use it or name alternative tools, so it lacks explicit exclusions/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?

No annotations are provided, so the description must fully disclose behavior. It only adds that the tool is 'Free' and does not mention return formats, pagination, or the discrepancy between 'open' and the status parameter. This is insufficient for a zero-annotation 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 description is a single concise sentence that wastes no words, stating the core function and key filters efficiently.

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, no annotations, and low parameter coverage, the description needs to compensate. It does not mention the status enum, limit parameter, or return behavior, leaving significant gaps for an agent to invoke 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 only 25% (only wallet is described). The description mentions filtering by symbol and creator wallet, but omits the 'recipient' part of the wallet filter (contradicting the schema) and does not explain limit or status. It adds minimal value over the sparse schema.

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

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

The description clearly states the action ('Browse') and resource ('open conditional settlement contracts'), distinguishing it from settlement_create and settlement_trigger. However, 'open' is potentially ambiguous given the status filter includes other states, which slightly undermines clarity.

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 on when to use this tool versus alternatives like futures_browse or marketplace_browse. The description implies browsing use cases but provides no exclusions or alternative tool references, leaving the agent to infer differentiation.

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 burden. It discloses meaningful behavioral traits: the 1% platform fee on settlement, free creation, tracking/proving by SqueezeOS, and direct wallet settlement. It does not cover auth, rate limits, or side effects like what happens if a condition is never met, leaving some gaps.

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 (three sentences) and front-loaded with the primary purpose. Each sentence adds useful context, though 'Free to create' is somewhat redundant with the fee explanation. It is well-structured and avoidable fluff is minimal.

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 8 parameters, no output schema, and no annotations, this description covers the core workflow, conditions, and financial implications. It does not mention what the creation response contains (e.g., contract ID) or next steps, but given the rich schema, this is a minor gap. Overall, it is reasonably complete for a creation 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 description coverage is 88%, which is high, so the baseline is 3. The description adds the list of condition types and the fee context, which slightly clarifies condition_value expectations, but most parameter meaning is already in the schema. It adds minimal semantic value 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?

Clearly states the action: 'Create a conditional agent-to-agent escrow contract.' This distinguishes it from siblings like settlement_browse and settlement_trigger, and the resource (escrow contract) is specific. The condition types are enumerated, reinforcing the 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?

Implied usage is clear (create a contract when you want conditional settlement), and the fee structure provides context. However, there is no explicit guidance on when to use this instead of settlement_trigger or other alternatives, nor any 'when not to use' 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?

The description discloses that it publishes a settlement proof to SSE stream and returns proof on success, and mentions it is free. It also states 'Anyone can call,' covering access control. It does not detail failure modes or state changes beyond settlement, but enough context is provided given no annotations exist.

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

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

The description is two concise sentences, front-loading the primary action. No 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 single-parameter tool with no output schema, the description covers purpose, side effects, return value, caller permissions, and cost. It is complete enough for an agent to invoke 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 only parameter, contract_id, is fully documented in the schema with the description 'UUID from settlement_browse.' The tool description does not add additional parameter semantics, so baseline of 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 clearly states the tool's function: checking if a settlement contract's condition is met and settling it if so. It distinguishes from siblings like settlement_browse and settlement_create by focusing on the trigger 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?

The description indicates who can call (anyone) and mentions it is free, but does not explicitly contrast with alternative tools or state when not to use it. The action is implied when a settlement contract is ready to be finalized, but no explicit exclusionary guidance 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. It discloses the result limit (200), ordering (newest first), free availability, and the categories of signals. It does not describe return format or error behavior, but for a simple historical query this is reasonably transparent.

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, using three short sentences to convey the core purpose, the signal types, ordering, cost, and intended use case. Every word is purposeful and there is no redundancy.

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

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

For a simple tool with one parameter and no output schema, the description provides the essential context: what data is returned, for whom, and why. It could be slightly more explicit about the return structure, but given the low complexity, 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 100% (the only parameter 'symbol' is described as 'Equity ticker'). The description adds no additional meaning beyond what the schema already provides, so the baseline score of 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 clearly states the tool returns the last 200 recorded signals for a symbol, listing the specific signal types (SQUEEZE_ALERT, OPTIONS_SWEEP, COUNCIL_VERDICT, MARKETPLACE_LISTING). It specifies the ordering (newest first), which distinguishes it from sibling tools like signal_preview or marketplace_read_signal.

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

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

The description implies the tool is for backtesting and confidence calibration, giving a clear context for use. However, it does not explicitly name alternatives or state when not to use this tool, so it lacks explicit exclusion 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 burden. It discloses the 15-minute cache and that the tool is not tradeable, adding meaningful behavioral context. It doesn't mention rate limits or output format, but for a simple preview 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?

Two short sentences, front-loaded with the core purpose, and no filler. Every clause adds useful 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?

The tool is simple (one parameter, no output schema), and the description provides cache info, non-tradeable status, and an alternative. It doesn't specify the exact return structure, but the context is sufficiently complete for a preview 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% for 'symbol' (described as 'Equity ticker'), so the description adds little beyond reinforcing 'any symbol.' No new parameter-level details are provided.

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 provides a 'bias + regime preview' for any symbol, with an explicit contrast to council_verdict. The verb 'preview' and the resource are specific, distinguishing it from 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?

It provides explicit guidance: 'Not tradeable — use council_verdict for full thesis.' This tells the agent when not to use it and names the alternative, making usage boundaries clear.

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 the exact output (ABOVE or BELOW), the meaning of each state, and the limitation that no raw EMA values or price levels are returned. It also mentions the proprietary calculation and cost (0.03 RLUSD), though it doesn't elaborate on payment mechanics or edge cases.

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 (two sentences) and front-loaded with the tool's name and pricing. Every sentence adds value: the first defines the tool and its output, the second clarifies what is not returned and notes the proprietary calculation. No 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 signal tool, the description provides sufficient context: it explains the output semantics, the exclusion of raw values, and the cost. It lacks details about error cases or payment flow, but the schema covers parameter requirements and the output is simple enough that no additional return-format explanation is needed.

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% for all three parameters, so the score defaults to baseline 3. The description adds no further parameter-specific meaning; the 0.03 RLUSD cost is mentioned in the description but also aligns with the payment_token parameter described in the schema.

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

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

The description clearly identifies the tool as an 'SML 365-Day EMA Anchor Signal' with a specific verb ('Returns') and resource ('ABOVE' or 'BELOW' states). It distinguishes itself from siblings by specifying the 365-day EMA and explicitly noting that no raw values are returned, setting it apart from other sovereign_* signal 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 implies the tool is used to assess macro bull/bear structure via the 365-day EMA, but it provides no explicit when-to-use guidance or exclusions relative to the many sibling tools (e.g., sovereign_full, sovereign_triplelock, proprietary_ema_signal). There are no named alternatives or usage contexts.

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 transparency burden. It discloses that the tool returns only labels and explicitly states it never returns EMA values, spreads, or price data. It also explains the meaning of each signal label, which goes beyond basic output 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 description is three sentences and immediately front-loads the core purpose: a paid signal returning one of three labels. Every sentence adds value: cost, output labels with conditions, and explicit exclusion of raw data. No redundancy or filler.

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

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

Given the absence of an output schema, the description thoroughly explains the possible return values (BULLISH/BEARISH/CONSOLIDATION) and their meaning. It also clarifies limitations (no EMA values, etc.). It lacks explicit error-handling or prerequisite steps, but the sibling verify_payment tool and schema cover the payment requirement adequately.

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

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

The input schema already provides 100% coverage for all parameters, including descriptions for symbol, agent_wallet, and payment_token. The description adds no additional parameter semantics beyond the 0.02 RLUSD cost, which is already present in the payment_token schema description. Baseline score of 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 clearly states the tool returns a specific signal classification: BULLISH HIGHWAY, BEARISH HIGHWAY, or CONSOLIDATION. It names the resource ('SML 741 Macro Highway Signal') and distinguishes itself by noting that only labels are returned, never raw data.

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 context is implied through the description of signal meanings (e.g., squeeze_alert=true indicates a likely breakout), so an agent can infer when this tool is useful. However, it does not explicitly compare with sibling tools like macro_741_scan or sovereign_triplelock, nor does it 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?

Since no annotations are provided, the description carries the full burden and does well. It discloses the pricing (0.10 RLUSD), the verdict logic, the squeeze_alert feature, and explicitly states that no raw values, EMA levels, or indicator readings will ever be returned. This is rich behavioral context beyond basic tool purpose.

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 in the description provides value: the pricing, the engines, the verdict definitions, the squeeze alert, and the explicit limitation on raw values. The information is front-loaded and logically organized, with 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?

Without an output schema, the description fully explains the possible return values (four verdicts and squeeze_alert) and what will not be returned. It is sufficiently complete for an agent to know what to expect, though it does not specify the exact JSON shape or error handling.

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 100% description coverage for all three parameters. The tool description adds context about the payment cost (0.10 RLUSD) but does not add new meaning to the parameters themselves. Baseline of 3 is appropriate because schema already documents each parameter.

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 runs all three sovereign engines and combines them into a single verdict, with specific output states (BULL, BEAR, TRANSITIONAL, STANDBY). It names the sibling engines (741, 365, Triple Lock), making it easy to distinguish from the individual sovereign_* 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 clearly implies when to use this tool: to get a combined verdict across all three engines rather than individual engine outputs. It does not explicitly state exclusions or name alternatives, but the context of 'Full Stack' and the enumeration of the three engines indicates its role 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 provided, the description carries the full burden, and it does well by disclosing the 0.05 RLUSD cost, listing all four possible output labels, and explicitly stating that only labels are returned (no engine names, theses, or raw values). It does not cover failure modes or state effects, but the payment-token schema plus the label-only boundary give substantial 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 compact and front-loaded with the signal name and cost, then immediately enumerates output values. The final sentence 'Labels only' is slightly redundant with the preceding exclusion, but it serves as emphasis rather than 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?

There is no output schema, so the description appropriately explains all possible return labels and the tool's constraints. It does not clarify whether FORMING includes directional context or how this tool relates to sibling signal offerings, but the core contract is complete enough 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 100%, with each parameter already clearly described (ticker, XRPL wallet address, JWT from verify_payment). The tool description adds no parameter-specific detail, so the schema carries the explanatory load; 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 clearly states the tool returns an SML Triple Lock Consensus Signal and enumerates all possible output labels (LOCKED BULL, LOCKED BEAR, FORMING, UNLOCKED), making its purpose unambiguous. It also distinguishes itself from sibling signal tools by explicitly noting that engine names, theses, and raw values are not returned.

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 contextual usage guidance (e.g., UNLOCKED means wait for alignment) but does not explicitly state when to use this tool versus siblings like sovereign_full or convergence_check. It offers no exclusions or alternative-recommendation language, leaving tool selection somewhat implicit.

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 bears the full burden of behavioral disclosure. It explicitly states the tool returns uptime and version, and the term 'health check' implies a read-only operation with no side effects. While it doesn't explicitly say 'does not modify state', the context is clear for such a trivial system status 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 description is extremely concise, using three short sentences to convey purpose, output, and a note about cost. Each sentence contributes value, and the main purpose is front-loaded. There is no wasted text or redundancy.

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

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

Given the tool's simplicity (no parameters, no complex options, no output schema), the description sufficiently explains what the tool does and what it returns. The behavior is fully captured for an agent to decide whether to invoke it. The absence of an output schema is not an issue since the description already specifies the return contents.

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

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

The tool has zero parameters, so the input schema provides no semantic burden. With 0 parameters, the baseline score is 4, and the description correctly focuses on the tool's output rather than parameters. No parameter documentation is needed.

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's function: a system health check returning uptime and version. It specifies the resource (SqueezeOS system) and the output, which distinguishes it from other tools in the sibling list that focus on trading, market scanning, or file operations.

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 offers no explicit guidance on when to use this tool versus alternatives. It mentions 'Free' which might imply no cost but does not explain when the user needs a system health check versus other tools. There are no exclusions or alternative suggestions.

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 fully carries the transparency burden. It discloses cost, independent source querying, variance measurement, confidence based on agreement, HMAC proof hash, and the edge case of fewer than 2 providers (single-source-unverified). This is exceptionally transparent.

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 every sentence adds value: cost, methodology, integrity proof, and edge behavior. It is well-structured and front-loaded with the core purpose, with no 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?

Given the tool's complexity (multisource consensus, payment, integrity verification), sparse schema, no annotations, and no output schema, the description covers essentials: behavior, return expectations (consensus_method, proof hash), prerequisites, and edge cases. It is sufficiently complete for an agent to invoke 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 coverage is only 33% (only symbol described). The description adds meaning by explaining payment_token comes from verify_payment and that agent_wallet is required, partially compensating for the missing schema descriptions. It does not fully specify agent_wallet format, but the critical payment flow is clarified.

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 queries Tradier, Alpaca, and Polygon independently and returns a consensus price with variance/spread, distinguishing it from fake or single-source quotes. It is a specific verb+resource description that sets it apart from siblings like oracle_query or iam_truth.

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

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

The description provides clear context: it is a paid tool that requires payment_token from verify_payment plus agent_wallet. It implies when to use it (when a verifiable consensus price is needed) but does not explicitly mention alternatives or 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?

No annotations are present, so the description carries the full burden. It discloses the return value (JWT with 1-hour TTL), its purpose, and that the tool is free. This is meaningful behavioral context, though failure modes and prerequisites aren't mentioned.

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 concise sentences that front-load the action and result, with zero redundant text. Every word adds value.

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 verification tool, the description covers the essential flow: submit tx_hash, get token. It lacks error handling or edge-case context, but the schema and purpose are sufficient for most use cases.

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 75%, and the description reinforces tx_hash and agent_wallet meaning but adds little beyond schema. The invoice_id parameter is not explained in the description, so parameter semantics are average.

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?

Description clearly states the tool's function: submit an XRPL tx_hash to verify an invoice payment and receive a JWT access token. This specific verb+resource approach distinguishes it from siblings like get_invoice or ccs_validate.

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

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

The phrase 'after paying an invoice' provides clear contextual guidance on when to use this tool, and the return token is positioned for use as payment_token. It doesn't explicitly name alternative tools or exclusions, but the context is strong.

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