RWA Data MCP Server

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

Annotations already declare readOnlyHint=true, so safety is covered, but the description adds real value beyond that: the cost behavior (FREE, polling never costs) and the state machine plus the fact that a completed task yields the brief markdown and sources. No output schema exists, so disclosing the return payload here is a genuine contribution.

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

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

Two tight sentences with zero filler; the cost note and the return-state list are front-loaded, and every clause carries information an agent needs.

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 polling tool with no output schema, the description covers what it does, its cost, and what it returns, which is nearly everything needed. Minor gaps remain around polling cadence and terminal-state handling, but the agent can call 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 description coverage is 100%; the task_id parameter is fully documented in the schema, including a concrete example and its provenance from request_brief. The description adds no further parameter semantics, so the baseline 3 applies.

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

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

The description states a specific verb and resource: "Check the status of a custom brief task," and enumerates the returned states (queued/working/done/failed). It ties to the sibling request_brief via the task_id reference, though it never explicitly distinguishes itself from get_brief.

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?

"polling never costs" strongly implies this is the polling tool and is safe to call repeatedly, which is useful usage context. However, it never states when to use this versus get_brief, nor when to stop polling (e.g., once done/failed), leaving the workflow to inference.

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

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

Goes well beyond the readOnlyHint annotation by disclosing the paid nature of the call ($0.01 USDC per call), the payment rail (Solana mainnet), and the challenge-response handshake required before data is returned. These are exactly the operational facts an agent needs to avoid a failed call.

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 dense sentences with no filler, and the metric scope is front-loaded ahead of the payment mechanics. Slightly packed, but every clause carries 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 single-parameter, no-output-schema tool, the description covers scope, cost, and the full invocation sequence. Nothing an agent needs to call it successfully is missing.

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

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

Schema description coverage is 100% and the single parameter is fully documented in the schema, so the baseline is 3. The description reinforces the payment semantics of payment_signature but adds no syntax or format detail the schema does not already carry.

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

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

States a specific verb+resource ('Every tracked metric in one call') and enumerates the covered domains (stablecoin, RWA, DeFi, L2, prediction-market, agent-economy). 'In one call' implicitly distinguishes it from the singular sibling get_metric, so an agent can route correctly without opening schemas.

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

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

Gives an explicit two-step invocation protocol: omit payment_signature to receive a challenge, pay, then re-call with the signature. It lacks any comparison to sibling tools like get_metric or get_price, so it falls short of the 'when-not/alternatives' bar for a 5.

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

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

Goes well beyond the readOnlyHint annotation by disclosing the paid-access model: $0.25 USDC per call, Solana mainnet settlement, and the challenge/response handshake. These are exactly the operational facts an agent needs and are not in the annotations or 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?

Two dense sentences, front-loading what the brief contains and then the payment mechanics. No filler and nothing buried.

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

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

With no output schema, the description carries the return-shape burden and does so ('total + breakdown, insights, risks'), plus the full payment flow. An agent has everything needed to call 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 description coverage is 100%, and the schema already explains topic selection and the omit-then-resubmit pattern for payment_signature. The description restates the payment flow but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific resource and its contents: a 'structured market brief' with 'total + breakdown, insights, risks.' An agent knows exactly what it gets. It does not, however, differentiate itself from siblings like get_metric or get_price, so it stops 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?

Gives explicit two-step usage: first call without payment_signature yields the challenge, then pay and re-call with the signature. That is clear procedural guidance. It omits when to prefer this brief over sibling tools like get_metric or verify_claim.

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?

Annotations only declare readOnlyHint=true, but the description discloses cost ($0.01 USDC per call), the payment rail (USDC on Solana), and the mandatory two-call challenge/retry sequence. That is exactly the kind of behavioral context annotations cannot carry, and it is fully consistent with the read-only hint.

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

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

Two sentences, zero waste. Purpose and cost come first, then the invocation sequence, so the most decision-relevant facts are 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?

There is no output schema, so the description carries some return-value burden; it explains the first-call return (payment challenge) but not the shape of the metric payload itself. For a paid tool the critical flow is covered, so this is nearly 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%, so both parameters are already documented in the schema, including the first-call/retry semantics of payment_signature. The description reinforces the flow and adds the price, but contributes no new syntax or format detail beyond the schema, which is the baseline-3 case.

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

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

States a specific verb and resource ('Get one verified stablecoin/RWA market metric') and adds a distinguishing qualifier ('verified'), which separates it from vague siblings like get_price or get_peg. It does not, however, explicitly contrast itself with those siblings, so it lands at clear-but-undifferentiated.

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 two-step payment flow is spelled out precisely: call without payment_signature to get the challenge, pay, then call again with the signature. That is strong operational guidance. What is missing is any when-to-use-this-vs-alternatives guidance relative to get_price, get_peg, or get_monitor_pegs.

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?

Annotations only declare readOnlyHint, but the description adds substantial behavioral context beyond that: the exact cost ($0.01 USDC per call), the payment rail (USDC on Solana mainnet), and the challenge/retry auth handshake. This is precisely the auth-and-cost disclosure the annotations cannot carry.

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

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

Two tight sentences: the first front-loads what is returned and the price, the second lays out the payment sequence. No filler, and the ordering matches how an agent must act.

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

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

With no output schema, the description must imply the return shape; 'all four tracked stablecoin pegs' conveys coverage but not what fields come back per peg (price, deviation, timestamp). Everything needed to invoke it correctly, including payment, is present.

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

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

Schema coverage is 100% and the sole parameter's schema description already explains the omit-then-retry flow, so the description largely restates it. Baseline 3 applies since the schema does the heavy lifting and the description adds no syntax or format detail beyond it.

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

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

States a specific verb and resource ('all four tracked stablecoin pegs') and enumerates exactly which pegs (usdt, usdc, usde, dai) are returned in one call. This clearly separates it from the sibling get_peg, which presumably returns a single peg.

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

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

Gives an explicit two-step invocation flow: call without payment_signature to get the challenge, pay USDC on Solana, then call again with the signature. It does not, however, say when to prefer this batch call over the single-peg get_peg sibling, leaving that choice to inference.

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

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

Goes well beyond the readOnlyHint annotation by disclosing the paid nature of the call ($0.01 USDC), the settlement network (Solana mainnet), and the challenge-then-pay protocol. It does not cover failure modes (expired signature, insufficient payment) or latency, keeping it short of a 5.

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

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

Two sentences, zero filler, and correctly front-loaded: the value proposition and unit of measurement come before the payment mechanics. Every clause carries information an agent needs.

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

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

For a read-only tool with no output schema, the description sketches the return content (price and bps deviation) and fully explains the payment gate. Missing only failure/retry behavior if payment is not recognized.

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 payment_signature already fully documented in the schema, so the baseline is 3. The description adds the cost context and the ordering of the two calls but no new syntax or format detail for the parameters themselves.

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

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

Names a specific resource and measurement: stablecoin peg status with live price and deviation in basis points from $1.00. It does not explicitly differentiate itself from siblings get_price or get_monitor_pegs, so an agent must infer the distinction from the 'peg/deviation' framing rather than being told.

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

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

Gives an explicit two-step invocation sequence: first call without payment_signature yields the payment challenge, pay, then re-call with the signature. That is concrete when/how guidance for this tool's gating flow, but it never states when to prefer this over get_price or get_monitor_pegs.

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 readOnlyHint annotation already tells the agent the call itself mutates nothing, and the description goes well beyond it by disclosing the $0.01 USDC cost, the Solana mainnet payment requirement, and the required retry sequence. It stops short of covering failure modes such as challenge expiry or whether a signature can be reused.

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

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

Two tight sentences: the first front-loads what the tool returns and its price, the second explains the call sequence. No filler and 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?

With no output schema, the description still conveys what comes back conceptually (price plus source proof) and what the first unpaid call yields (a payment challenge). It omits error handling and the exact shape of the challenge/paid responses, which is a modest gap for a paid endpoint.

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 both id and payment_signature are already fully documented in the schema, including the omit-then-resend semantics. The description restates that flow in prose without adding format, validation or edge-case detail beyond the schema.

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

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

States a specific verb+resource: a point-in-time asset price with source proof, plus its cost. It is clearly distinct from sibling tools like get_peg, get_metric or get_brief, though it never names an alternative to route the agent explicitly.

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

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

Gives clear, actionable context for the two-call payment protocol: omit payment_signature first to get the challenge, pay, then call again with the signature. It does not, however, compare itself against any sibling tool or say when a different price/peg tool would be preferable.

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 describes an ordering/payment operation that spends $1.50 USDC and creates a brief, while annotations declare readOnlyHint=true. That is a direct contradiction of the declared safety profile, matching the 'description claims a write while annotations say read-only' failure mode.

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 dense sentences, all front-loaded with the highest-value facts (what it is, price, allowed topics, latency, then the payment flow). Nothing is filler, though the payment flow sentence is long enough to be slightly heavy.

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

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

For a paid two-step tool with no output schema, the description covers price, latency, polling behavior, and the full challenge/pay/retry loop. It omits failure/refund behavior and what the delivered brief actually contains, minor gaps given 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?

Schema coverage is 100% and both parameters are well documented in the schema, so the baseline is 3. The description adds meaning beyond the schema by constraining valid topic values to five named lanes and by explaining the two-step semantics of payment_signature in workflow terms.

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

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

States a specific verb and resource ('Order a custom research brief on your topic'), plus scope constraints (allowed lanes) and cost. It is unmistakably distinct from siblings like check_brief_status, get_brief, or get_price.

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

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

Explicitly routes the agent: use check_brief_status to poll (and notes polling is free), call without payment_signature first to get the challenge, pay, then call again with the signature. When-to-use and the alternative tool are both named.

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?

Adds substantial context beyond the readOnlyHint annotation: the $0.10 USDC cost, the required Solana mainnet payment, the challenge/response handshake, and the three-valued verdict plus evidence/sources in the result. These are behavioral facts an agent cannot infer from the annotations or 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?

Two dense sentences, front-loaded with purpose and outcome categories before the payment mechanics. The cost parenthetical is slightly awkwardly placed mid-sentence, but nothing is wasted.

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

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

With no output schema, the description compensates by naming the possible verdicts and stating that evidence and sources are returned, and it fully covers the payment prerequisite. An agent has everything needed to call 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 description coverage is 100%, so both parameters are already fully documented in the schema, including the example claim and the omit-then-retry payment flow. The description largely restates that flow, so 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?

States a specific verb (verify) and resource (factual crypto-markets claim) plus the source of truth (sourced, dated claims cache), and enumerates the outcome space (confirmed/refuted/unverifiable). This clearly distinguishes it from the retrieval siblings get_price, get_metric, get_peg, etc.

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

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

Gives explicit operational guidance for the two-step payment flow: first call without payment_signature yields a challenge, then call again with the signature after paying. It does not name alternatives or state when-not-to-use, but for a paid verification endpoint the invocation context is unambiguous.

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