Agent Revenue Network

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

Beyond the readOnly, idempotent, and non-destructive annotations, the description discloses that this is a free discovery call that does not execute the advertised capability or charge, that paid execution counts field presence, missing/null values, primitive types, cardinality, and exact duplicates, and that it returns the x402 endpoint, price, and payment guide.

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 tightly written, with the purpose front-loaded and each sentence adding useful information about capability, alternatives, exclusion, and discovery/payment behavior. The important caveat that this is a free discovery call rather than execution is placed last, which is slightly less ideal structurally but does not make the description 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?

For a one-parameter tool with an output schema and rich annotations, the description supplies the missing context: what profiling metrics would be counted under paid execution, how this free discovery call differs, and what it returns. Nothing essential for correct invocation appears to be 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%, so the single rows parameter is already fully documented with its 1-5,000 item bounds and object type. The description repeats the same range and JSON-object framing without adding new syntax or handling details beyond what the schema already provides.

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

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

The description states a specific verb and resource (deterministic data-quality profiling for JSON-object rows) and later clarifies that the call itself is a free discovery endpoint that returns execution metadata. It distinguishes itself from schema_infer and tabular_validate, though the initial framing as profiling could briefly mislead an agent because the call does not actually execute the profiling.

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 names concrete alternatives: use schema_infer to draft a flat-record contract or tabular_validate to enforce one, and explicitly excludes statistical inference. It also explains the paid-execution versus free-discovery distinction, providing clear context for when to use this call, though it does not list every profiling alternative among the siblings.

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

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

Annotations already declare readOnly/idempotent/non-destructive, and the description adds substantial context beyond them: arrays are compared by index, results cap at 1,000 added/removed/changed records with JSON paths and before/after evidence, no JSON Patch output, and the free call charges nothing but returns an x402 endpoint, price and payment guide. This is exactly the execution-model 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?

Front-loaded with the core capability, then output limits, then exclusions, then alternatives. Dense but every sentence carries routing or behavioral information; the x402/payment sentence is long but necessary given the discovery/execution split.

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?

An output schema exists, so return values need not be described, and the description still covers comparison semantics, record caps and the discovery/paid-execution model. An agent has everything needed to decide to call it and to interpret the free-call result.

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

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

Schema coverage is 100% for both required params, so baseline is 3. The description adds real comparison semantics not in the schema ('compares arrays by index'), which affects how before/after inputs are interpreted.

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 ('deterministic structural JSON diff between before and after values') and explicitly scopes what it does not produce ('does not generate JSON Patch'). It also names sibling tools (json_normalize, json_schema_check) that an agent might confuse with 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?

Explicitly routes to alternatives with their conditions: json_normalize for stable serialization, json_schema_check for validity. It also clarifies the free-discovery vs paid-execution split. It stops short of stating when json_diff itself is the wrong choice (e.g., text/table comparison belongs to tabular_diff), so it falls just under full coverage.

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 already declare readOnlyHint, idempotentHint and destructiveHint=false, so the safety profile is covered; the description adds genuinely non-obvious context — that this call is free, does not execute the advertised paid capability, and returns the x402 endpoint, price and payment guide. It also discloses the normalization semantics (recursive key sort, array order preserved). It is slightly muddled in that most of the text describes the remote paid capability rather than this MCP tool's own 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 capability and the discovery-call caveat are front-loaded, and the sentence count is reasonable for the amount of routing and payment context conveyed. It loses a point for restating the key-sorting semantics that the input schema already documents verbatim.

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?

An output schema exists so return values need not be spelled out; the description still covers routing, exclusions, cost, and the fact that execution is deferred to a paid endpoint — everything an agent needs to call this correctly. Minor gap is that it never says what the discovery response's fields look like at a glance, leaving that entirely to the 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?

Single parameter with 100% schema description coverage, so the baseline is 3. The description restates the same normalization semantics already present in the 'value' property description ('object keys are recursively sorted; array order and scalar values are preserved'), adding no syntax, format, or constraint information 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 ('discover deterministic JSON normalization for any JSON value') and explicitly delimits scope, naming the sibling to use instead for change detection ('use json_diff to identify changes') and disclaiming a commonly-confused standard ('never treat this as RFC 8785/JCS canonicalization'). An agent can distinguish this from json_diff and json_schema_check without opening any schema.

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

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

Gives concrete when-to-use cases ('stable comparisons, cache keys and repeatable payloads'), an explicit alternative with its triggering condition ('use json_diff to identify changes'), and a when-not-to-use warning about JCS canonicalization. Nothing about routing is left to inference.

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

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

Annotations already declare readOnly/idempotent/non-destructive, but the description adds decisive context they cannot: this is a discovery call that does not execute the advertised capability, does not charge, and returns an x402 endpoint, price and payment guide. That reframes what calling the tool actually does and prevents a serious misread.

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

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

Front-loaded with the capability, followed by supported-keyword scope, sibling routing, and the discovery/payment caveat. It is dense but every sentence carries information; the keyword enumeration is long yet functional.

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 an output schema present, the description needn't explain return values, and it still discloses the discovery/payment nature of the response. The supported-subset scope and the fail-closed behavior are covered, leaving little an agent needs before invoking.

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 both parameters (value, schema) are well documented in the schema itself, so the baseline is 3. The description lists supported keywords but adds no syntax or format detail beyond what the schema already provides for these two params.

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 ('recursive JSON Schema checking for objects, arrays and scalars') and names the sibling it is not ('Prefer object_contract_check for a new simple top-level contract'). An agent can distinguish it from the many sibling validation tools without opening a schema.

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

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

Names an explicit alternative (object_contract_check) and the condition that selects it (a new simple top-level contract), which is clear routing guidance. It stops short of stating when this tool is the right choice versus that sibling, so it is not fully two-sided.

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 already cover read/idempotent/destructive hints, but the description adds critical context beyond them: this is a discovery call that does NOT execute the advertised capability, does not charge, and returns the exact x402 endpoint, price and payment guide. That overturns the natural assumption that calling this validates a payload, which is exactly the kind of behavioral disclosure that prevents misuse.

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, all front-loaded and purposeful: purpose, mechanics, alternative, then the payment/discovery caveat. Slightly dense but no filler; minor tightening possible around the discovery sentence.

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 an output schema present, return values need not be explained. The description covers scope, evaluation limits, sibling routing, and the discovery/payment model — everything an agent needs 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 coverage is 100%, so baseline is 3, but the description maps each schema element to its behavioral effect (required finds absent fields, properties.<field>.type finds primitive type mismatches, additionalProperties=false reports unknown fields). That adds semantic meaning beyond the raw schema definitions, though it does not cover edge cases like type coercion or duplicate handling.

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 ('deterministic top-level JSON field validation') and immediately scopes it to what is actually evaluated. It distinguishes itself from the sibling json_schema_check by naming it explicitly. An agent can select this tool without opening the schema.

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

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

Gives an explicit routing rule: 'Prefer this for new simple contracts and use json_schema_check for nested or recursive constraints.' Names both the condition and the alternative, leaving nothing 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, and the description adds real value beyond them: the call is free, does not charge, does not execute the advertised capability, does not perform or certify the underlying checks, and returns the x402 endpoint, price and payment guide. This pricing/no-side-effect disclosure is exactly the kind of context annotations cannot convey, though the mixing of paid-execution behavior with discovery-call behavior slightly muddies which statements apply to this 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?

The purpose is front-loaded, but the passage is dense and carries some redundancy: 'does not execute the advertised capability' largely restates 'does not perform or certify the underlying checks,' and the paid-vs-free framing takes several clauses to resolve. It is not bloated to the point of harm, but every sentence does not cleanly earn its place.

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

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

With an output schema present and rich annotations, the description need not explain return values, and it appropriately focuses on the payment/discovery model and the non-execution guarantee. For a two-parameter nested-object tool, the agent has enough to call it correctly, though the relationship between the free discovery call and the paid comparison could be stated more crisply.

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 nested snapshot/check objects are fully documented in the schema, so the schema carries the parameter burden. The description enumerates the nine gate categories (functional, security, privacy, copyright, regulatory, transactionIntegrity, abuse, regression, economics) and mentions candidate identity metadata, which mirrors rather than extends the schema.

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

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

The description states a specific verb and resource ('deterministic comparison of a previous and current execution-evidence snapshot') and names the sibling verify_execution, so it is distinguishable from json_diff and verify_execution. The wrinkle is that this MCP call is actually a discovery/quote endpoint rather than the comparator itself, which the text does clarify but only after describing the paid capability, adding mild ambiguity about what the call literally does.

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 clear context for use: prevents duplicate verification of unchanged evidence and indicates whether a fresh verify_execution purchase is warranted. It names the alternative (verify_execution) and the condition that selects it, though it does not spell out explicit when-not-to-use cases or input prerequisites beyond that.

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 annotations declaring readOnly/idempotent/non-destructive, the description still adds essential behavior the annotations cannot convey: this call 'does not execute the advertised capability and does not charge,' and it returns an endpoint, price and payment guide instead. It also discloses execution semantics (typed composite key, first-occurrence preservation, count reporting) for the downstream paid call. Some of that describes the advertised capability rather than this call, which slightly blurs the picture.

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 dense sentences with little waste; the alternative and the key behavioral constraint all earn their place. Structure is slightly off because the capability semantics are front-loaded ahead of the actual 'this is a non-executing discovery call' disclosure, which an agent most needs to know first.

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?

An output schema exists, so return values need not be detailed, and the description covers the discovery nature, cost, alternative tool, and execution semantics. Complete enough for correct invocation, though a clearer statement of what the discovery response contains and the distinction from the paid call could be sharper.

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 both required parameters documented ('one to eight field names that together form the record identity', 'rows to deduplicate while preserving first occurrence'). The description's mention of 'one to eight identity fields' and first-occurrence preservation restates schema/documentation content, adding little syntactically, so the 100%-coverage baseline 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 names a specific action (free discovery call returning the x402 endpoint, price and payment guide) and a specific resource domain (JSON-record deduplication), and it explicitly separates this discovery call from the advertised paid capability. However, the lead sentence describes the paid execution semantics rather than the actual behavior of this tool, so the true purpose is only revealed in the final sentence — mildly muddled against a title that reads like a mutating dedupe operation.

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

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

It gives an explicit alternative with a selecting condition: 'use dataset_profile when you only need duplicate measurement.' It also clarifies when this tool applies versus paid execution. No further when-not guidance is offered, but the routing condition is concrete.

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 already cover the safety profile (readOnly, idempotent, non-destructive, not open-world), yet the description still adds substantive behavior: exclusion of unhealthy and over-maxPrice candidates, quality defaulting to successRate, and the empty-eligible-set fallback returning selected=null with a reason. This is real context beyond structured fields.

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

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

Front-loads the operation and result, then the exclusion rules, then the usage caveat — a logical order with no filler. It is a dense single paragraph and the final clause about being 'free read-only' lightly overlaps annotation territory, but nothing is off-topic.

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 nested input objects, a 100% covered schema, an output schema, and full annotations, the description supplies the remaining decision-relevant facts: exclusions, defaults, the 1000 cap, and the null-return edge case. An agent has everything needed to invoke and interpret it.

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

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

Schema description coverage is 100%, so the baseline is 3; the description earns above that by explaining cross-parameter semantics — that the 1000-item list is caller-supplied, that unhealthy candidates are dropped, and that maxPrice filters the set. It does not, however, detail the ranking formula weights.

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 ('Rank up to 1,000 caller-supplied providers by quality, success rate, price and latency') plus the exact return shape (one selection plus at most three alternates). No sibling in this utility set does provider ranking, so it is clearly distinguishable.

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 bounds usage: 'Use this free read-only calculation only with comparable metrics you already hold because it neither discovers providers nor verifies measurements.' It states both the qualifying condition and the two things the tool will not do, removing any inference about scope.

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 cover the safety profile (readOnly, idempotent, non-destructive, openWorld), and the description adds non-obvious behavioral detail beyond them: required fields are only marked when every row is non-null, nested structures are rejected rather than guessed, and — critically — the free MCP call does NOT execute the capability but returns the x402 endpoint, price, and payment guide. That payment/execution split is exactly the kind of context annotations cannot express.

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, front-loaded with the capability and semantics before the sibling routing and payment disclosure. Efficient overall, though the free-call/payment sentence is dense and slightly awkward alongside the execution-focused opening.

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?

An output schema exists, so return-value explanation is unnecessary, and the description is complete enough to call the tool correctly given a single, fully documented parameter. Minor residual ambiguity about how the free discovery call relates to the paid execution input (whether rows is consumed now or later) keeps this from a 5.

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

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

With only one parameter at 100% schema description coverage, the schema already documents 'rows' including the flatness constraint and item limits. The description's note that nested objects and arrays are rejected mirrors the schema description rather than adding new semantics, so the 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 and resource ('conservative JSON Schema inference from multiple flat JSON-object records') plus the intended applications (imports, API contract drafting, validation setup). It explicitly names and contrasts the siblings dataset_profile and json_schema_check, so an agent can distinguish it without opening any other schema.

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

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

Provides explicit routing: 'Use dataset_profile for descriptive counts or json_schema_check to validate against an existing schema,' which tells the agent exactly when a different tool is the right choice. It also states the input precondition (flat records only; nested objects and arrays rejected), removing ambiguity about when this tool applies.

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 already declare readOnly=true, idempotent=true, destructive=false, so the safety bar is lowered, yet the description still adds value: it labels the call "free" (cost/rate context) and bounds the meaning of the output so the agent does not over-trust it as verification of funding or legitimacy. Return format is not described, but an output schema 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?

Two sentences, front-loaded with the verb and the calculation outputs, followed by input guidance and a scope caveat. Dense but every clause earns its place; the second sentence is long but carries the unit rule, defaults, and the misuse warning.

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 6-parameter, fully schema-documented calculation tool with an output schema and complete annotations, the description covers purpose, input unit conventions, default behavior, and the limits of what the result proves. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100% and every parameter (fees, toolCost, failureLoss, executionCost, revenue, failureProbability) is already documented in the schema, including the internal default for failureLoss. The description restates the omitted-value defaults and the "same monetary unit" constraint, which is useful cross-parameter context but largely duplicates structured data.

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

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

States a precise verb and outputs ("Calculate risk-adjusted expected profit, margin and eligibility") scoped to "one proposed opportunity before execution." No sibling in the list does economics scoring, so there is no ambiguity to disambiguate, and the agent knows exactly what this returns conceptually.

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 timing ("before execution") and an explicit constraint on interpretation: "use ... as an economics screen, never as proof of funding, escrow, requirements or buyer legitimacy." It does not name alternative tools, but no sibling performs a comparable economic calculation, so there is little to route against.

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 already declare readOnly/idempotent/non-destructive, and the description adds substantial behavior beyond that: the free call does not execute the advertised capability, does not charge, and returns the x402 endpoint, price and payment guide. It also discloses that paid execution yields added/removed keys, changed rows with field-level evidence, and deterministic ordering.

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 front-loaded sentences with no filler, purpose stated first and pricing/execution caveats last. Slightly dense with multiple embedded clauses, but every sentence contributes routing or behavioral 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?

An output schema exists so return values need not be re-explained, and the description supplies the one non-obvious thing an agent needs: that this is a free discovery stub whose response is an endpoint/price/payment guide, plus what the eventual paid execution returns. Nothing required to call it correctly is missing.

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

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

Schema description coverage is 100%, so before/after/key are already documented by the schema. The description adds only the notion that records are keyed by one unique field, which mildly clarifies the 'key' parameter but no format or syntax detail beyond the schema, matching the baseline 3 for full 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 names a specific verb (discover/compare) and resource (row-level comparison of JSON-record tables keyed by one unique field), and it clarifies at the end that this is a discovery call returning an x402 endpoint rather than an executor. The tension between the name/title ('tabular_diff', 'Tabular Comparison') which imply actual diffing and the reality of a paid-execution discovery stub is resolved only in the final sentence, so slight ambiguity remains.

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 names two alternative siblings and their distinct purposes: json_diff for arbitrary nested JSON and tabular_validate to enforce row contracts. It also states the precondition that CSV/spreadsheet rows must be converted to JSON first, leaving no routing decision 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?

Beyond the annotations (readOnly/idempotent/openWorld/non-destructive), the description discloses the critical fact that this MCP call does NOT execute validation, does NOT charge, and instead returns the x402 endpoint, price and payment guide, while paid execution is what actually checks rows. This is exactly the behavioral context an agent needs and that annotations alone could not convey.

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

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

Front-loaded with the capability and scoped efficiently, but the remaining content is packed into semicolon-heavy clauses that read densely. It earns its length but could be 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?

With an output schema present, return values need not be explained, and the description covers the key ambiguity (discovery vs. paid execution). It is complete enough to call correctly, though it could state more concretely what the discovery response contains.

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 all three parameters are documented in the schema. The description gestures at the semantics (required columns, declared primitive types) but adds no syntax or format detail beyond the schema, 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?

The description gives a specific verb and resource ("deterministic pre-import validation for JSON-record tables") and scopes it to CSV/spreadsheet rows converted to JSON. It is clear about what the advertised capability does, though it splits its identity between the validation capability and the actual discovery call, which takes a beat to parse.

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

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

It explicitly routes the agent: use object_contract_check for a single object and json_schema_check for recursive constraints, and it clearly states when this tool applies (multi-row pre-import tables). Both alternatives and the selection condition are named, leaving nothing 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?

Annotations already declare readOnly/idempotent/non-destructive, and the description is consistent with them. It then adds genuinely non-obvious behavior beyond the annotations: no charge, no execution, and a return payload of x402 endpoint plus price and payment guide. That is exactly the kind of behavioral disclosure an agent needs before invoking.

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 dense sentences that front-load the capability and route scope before the crucial 'this does not execute' caveat. Some redundancy with the schema (routes and the 2,000-character limit appear in both), but no filler sentences.

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 payment/x402 discovery tool, the description covers the non-obvious essentials: no execution, no charge, and the exact return contract. An output schema exists so return values needn't be detailed, yet the description still summarizes them helpfully. Nothing an agent needs to call this correctly is missing.

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

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

Schema description coverage is 100% and the schema already documents every parameter, including the sourceLang default and the protectedTerms semantics. The description largely restates this (sourceLang defaults to EN, protectedTerms unchanged) plus a light note that context/domain/locale guide memory and wording. Marginal additive value, so the baseline 3 is appropriate.

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

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

The description states a specific verb (Discover) and resource (QA-verified translation), names the calibrated routes, and the 2,000-character scope. It is distinguishable from both the sibling tools and, crucially, from the actual execution capability. The wording 'Discover' is slightly euphemistic for what is really a pricing/endpoint lookup, but the third sentence removes the ambiguity.

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 frames the discovery context: it is 'free', 'does not execute the advertised capability and does not charge', and returns the endpoint/price/payment guide, which tells the agent when this call is the right choice versus the eventual paid execution. No sibling tools overlap, so no exclusions are needed. It stops short of an explicit 'use this before X' routing statement.

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

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

Annotations cover safety (readOnlyHint, idempotent, non-destructive), and the description adds the behavior they cannot: this call does not execute the advertised capability, does not charge, and returns the x402 endpoint, price and payment guide. It also discloses that paid execution returns candidate id, pass/fail and failed gate names.

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 essential disclosure (discovery-only, no charge, no execution) is well front-loaded, but the pricing economics sentence ('breaks even with 0.01-USDC pay-per-call at 1,900 checks') is obscure detail that inflates an already dense description for a two-parameter tool.

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

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

Given an output schema, a nested nine-boolean input, and the unusual payment/discovery framing, the description is complete: it covers gate semantics, the trusted-verifier precondition, non-execution, and what the paid path returns. 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 coverage is 100% so the bar is a baseline 3, and the description goes beyond it by stating the conjunctive rule (all nine caller-supplied booleans must be true) and clarifying that candidate.id is returned when present while candidate contents are not inspected. It adds meaningful semantics without contradicting 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 names a specific capability (deterministic acceptance checking across nine named gates) and is explicit that this call is a free discovery endpoint rather than the actual executing capability. It distinguishes itself from siblings like release_evidence_diff by scope, though the naming/purpose tension between 'verify_execution' and 'discovery call that does not execute' takes a careful read to 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?

It gives an explicit precondition ('Use only after trusted verifiers supply all nine booleans'), an explicit exclusion ('ARN does not scan code, audit systems or certify compliance'), and a named alternative for CI volume (Release Guard at 2,500 checks/30 days). Nothing is left to inference about when to reach for this tool.

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