Synthex Forge — x402 Paid Agent Services

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

The annotations already establish that this is a read-only, idempotent, non-destructive operation, so the description does not need to restate safety. It adds a cost signal ('$0.25 USDC') and a hint about the returned object having 39 fields, but this return-shape information is partly redundant with the output schema and the description does not explain permissions or rate limits.

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 but poorly structured: it is a run-on sentence mixing purpose, sibling routing, return-shape hints, and pricing. The key routing instruction is buried mid-sentence, and the '39 fields' detail is not front-loaded or clearly connected to the output schema.

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

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

With an output schema present and full schema description coverage, the description does not need to explain return values in detail. Still, for a tool whose name implies acceptance but whose description says 'grade the observations', the definition leaves the actual grading/acceptance semantics and the meaning of `spec` versus `observed` under-explained.

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 parameters are structurally documented, and baseline 3 applies. However, the schema descriptions are generic ('The spec this operation operates on'), and the tool description does not compensate by explaining what `spec` or `observed` should contain beyond the vague reference to observations.

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 ('Grade the observations') and explicitly contrasts the tool with the sibling `evaluate_deliverable_acceptance`, saying to use this one for task deliverables. That sibling differentiation is useful, though the phrasing is awkward and does not fully explain what 'grading observations' means in the context of accepting a task deliverable.

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: use this rather than `evaluate_deliverable_acceptance` for task deliverable, not deliverable acceptance. The condition is present but compressed into a confusing clause, and there is no broader guidance about prerequisites or when not to use this tool.

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

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

Annotations already declare readOnly/idempotent/non-destructive/closed-world, so the safety profile is covered. The description adds real value beyond that: it discloses the finding categories returned (over-granted scopes, wildcards, write-where-read-would-do, intent contradictions) and, importantly, the full payment protocol — price, network, payTo address, EIP-3009 flow, the 402 retry loop, and an SDK. That payment detail is essential operational context an agent cannot get from the schema.

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

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

The purpose is correctly front-loaded in the first sentence. But the 'VALUE' paragraph is marketing persuasion ('the exposure is the whole estate') that does not help an agent decide or invoke. The payment section is necessary given no auth field exists, so it earns its place, but the whole could be materially 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?

For a paid, read-only analysis tool with an output schema and full safety annotations, the description covers purpose and payment mechanics adequately. The gaps are the unresolved overlap with other permission-audit siblings and the unexplained `subject` parameter and permissions array shape, which an agent must guess when constructing the call.

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 nominally 100%, but every parameter description is the same placeholder string '[POST /v1/security/permission-audit]', which conveys no meaning. The description implies the semantics of `permissions.task` and `permissions.permissions` through the audit framing, but says nothing about `permissions.subject` or the expected shape of array items (typed as bare `{}`). Baseline 3 is warranted; the description neither compensates for nor worsens the hollow schema text.

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 pair ('audit an agent's declared permissions') and sharpens it with the comparison target ('against the task it claims to perform'), plus an enumerated list of what the report contains. An agent can tell this is a static permission-vs-intent analysis, not a runtime scan. It does not, however, distinguish itself from the near-identical sibling audit_declared_permissions, which an agent would have to disambiguate on its own.

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?

There is no explicit when-to-use, when-not-to-use, or alternatives statement. The description never mentions audit_declared_permissions, assess_tool_permission, agent_security_assessment, or run_agent_security_scan despite several siblings occupying adjacent territory. Usage must be inferred entirely from the purpose sentence.

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 read-only, idempotent, non-destructive, closed-world, and the description is consistent with them (

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 functional sentence is well front-loaded, but the 'VALUE:' paragraph is pure marketing ('a finding without a fix is a worry; a finding with a specific change is a ticket') and does not earn its space, and the payment instructions occupy more text than the tool's actual behavior. The PRICE/HOW TO PAY block is necessary, the VALUE block is not.

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 payment flow (price, asset, network, payTo, 402 retry, SDK) is fully covered — a real strength. What is missing is input guidance: with 10 all-optional parameters and content-free schema descriptions, an agent cannot tell what the minimum useful call looks like, which is the main functional gap given the tool's complexity.

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 nominally 100%, but every parameter description is the placeholder '[POST /v1/security/remediation]', so the schema conveys no semantics at all. The description says nothing about what to put in `findings` vs `files` vs `permissions` vs `tool_results`, or which are the minimum viable inputs for a 10-parameter, zero-required tool. The high coverage number earns the baseline 3, but the agent is left inferring meaning entirely from parameter names.

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 outcome — turns security findings into an actionable fix list, per finding: what to change, why, residual risk — which is concrete and distinguishable from a raw scan. However, the sibling set contains both `build_remediation_plan` and `agent_security_assessment`, and the description never says how this differs from `build_remediation_plan`, leaving the most confusable neighbor unresolved.

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 opening phrase 'Turn an agent's security findings into an actionable fix list' implies usage after findings exist, and 'coverage accounting' hints at review/audit contexts, but there is no explicit when-to-use, no prerequisite statement (e.g. 'requires output from agent_security_assessment'), and no named alternative. A sibling literally called `build_remediation_plan` demands disambiguation that is absent.

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 readOnly/idempotent annotations, it discloses the composite execution order, the shape of the result (verdict, findings with matched spans, named coverage gaps), and — critically — the payment requirement, price, asset, network, payTo address, and the exact unpaid-call failure mode (payment_required payload with fields pre-filled). That is exactly the kind of behavioral context annotations cannot carry. Coverage-gap disclosure is an unusually honest trait worth crediting.

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

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

Front-loaded and organized into PURPOSE/VALUE/PRICE/HOW TO PAY, with payment details that genuinely matter. But the VALUE paragraph re-argues the same point twice ('one decision, not three purchases' / 'one report that folds...') and is marketing framing rather than operational information. Roughly a third of the text is persuasion, not instruction.

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 restated, and payment mechanics are fully covered. The remaining gap: all 14 parameters are optional and the description never says what happens when only a subset (or none) is supplied — whether omitted detectors are skipped, defaulted, or reported as coverage gaps. That interaction between the empty-required list and the coverage-gap feature is left 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?

Schema coverage is 100%, so the baseline is 3, but the schema descriptions are only endpoint tags ([POST /v1/security/...]) rather than semantics. The description compensates by explaining the three detector groups and which inputs each consumes (prompts and tool descriptions for injection, text for credentials), which lets an agent map the 14 dotted-prefix parameters to their buckets.

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 specific verbs and resources: runs the agent scan, the prompt-injection detector over prompts and tool descriptions, and the credential detector over text, then returns a blocking verdict. It is far more than a restatement of the name. It does not, however, explicitly contrast itself with the sibling single-purpose tools (run_agent_security_scan, scan_prompt_injection, scan_secret_exposure), which are components of the same pipeline.

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 VALUE paragraph implicitly states when to use this tool: when the question is one deploy/no-deploy decision rather than three separate checks, this returns a single verdict. That is clear context for selection. It stops short of explicitly naming the alternative single-purpose tools or excluding cases where a reviewer only needs one detector.

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, non-destructive, closed-world), the description discloses the return shape (every attack surface found, ranked by severity, with evidence spans), the exact cost ($1.50 USDC), the payment mechanics (EIP-3009 transferWithAuthorization in an X-PAYMENT header, retry-on-402), and the failure behavior of an unpaid call. That is substantive behavioral context the annotations cannot 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?

Purpose is front-loaded in the first sentence, and the payment block is arguably necessary for a paid endpoint. The VALUE section restates some of what the first sentence already implies, and the SDK plug is marginal, so the text runs longer than needed but nothing is confusing.

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 no further explanation, and payment/auth details are fully covered. The remaining gap is that all six parameters are optional with defaults, yet the description never says whether at least one input group must be supplied or what an empty call yields.

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%, but the schema 'descriptions' are only endpoint tags such as '[POST /v1/security/prompt-injection]', so the description carries real semantic weight by explaining that the prompt.* group scans prompts, tool descriptions and tool results, while tools.* scans tool definitions and credentials.* scans text. It never mentions the credentials.files parameter, leaving that one input's expected content unstated.

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 ('Assess the threats TO an agent') and enumerates the three detectors it composes: prompt-injection over prompts/tool descriptions/tool results, tool-poisoning over tool definitions, and credential detection over text. This distinguishes it from single-surface siblings like scan_prompt_injection and audit_tool_poisoning, though those tools are never named explicitly, so the agent must infer the distinction.

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 VALUE paragraph gives a real selection rule: the three surfaces are assessed together because 'assessing one of them alone produces a clean report that means little.' That tells the agent when this composite is preferable to a single detector. It stops short of naming the narrower siblings or stating exclusions (e.g. when a single scan 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?

While annotations cover the safety profile (readOnly, idempotent), the description adds crucial behavioral details about the expected return format (an object with 3 fields including content, content_type) and the transactional cost ($29 USDC). This is highly valuable context beyond structured data.

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

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

The description is maximally concise. It packs the function, the necessary distinction from the sibling, the output structure, and the cost into one highly effective sentence with zero unnecessary padding.

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

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

Given that there are zero parameters, the definition provides all necessary information for an agent: what it is (Ebook download), what it costs, what it returns, and which sibling it should *not* be confused with. It is perfectly complete for its scope.

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 is empty (0 parameters). According to the rules, for zero parameters, the baseline score is 4, which is appropriate here as the description adds no semantic meaning to a non-existent parameter set.

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 purpose is immediate and clear: 'Ebook Download.' It uses a specific resource and successfully differentiates itself from the relevant sibling, `assess_agent_verdict`, by defining the operation (download vs. verdict).

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

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

This tool explicitly dictates its usage context: 'use it rather than `assess_agent_verdict` for ebook download'. This is the clearest possible guidance for an AI agent to prevent incorrect tool selection when multiple similar tools exist.

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, so the safety profile is covered. The description adds genuinely useful non-annotated context: a price of $0.02 USDC and an indication of a wide (~30 field) response. It omits anything about permissions, rate limits, or latency, and the output-shape note is partly redundant given 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?

It is short and front-loads the core question, then routing, output, and price in a sensible order. But the middle clause is a run-on fragment ("for agent verdict, not counterparty risk; an object with 30 fields...") that reads as truncated text and forces re-parsing, which undercuts an otherwise tight description.

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 and full parameter descriptions exist, so the description needn't explain return values, and it does supply price and an alternative. Still, given the dense crowd of `assess_*_verdict` siblings, it leaves unclear what signal decides "safe" and how it differs from assess_tool_verdict or get_agent_reputation.

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

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

Schema coverage is 100%, so both `address` and `chain` are already documented in structured form, which sets the baseline at 3. The description mentions "address" only incidentally as an output field and adds no format, defaults, or chain-selection semantics 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 frames the tool as a question ("Is this wallet safe to transact with right now?") and names a sibling it is not, which helps, but it never states the operation in verb+resource form and drifts between "wallet" and the tool's "agent verdict" name. Against a family containing assess_endpoint_verdict, assess_service_verdict, assess_tool_verdict and assess_counterparty_risk, an agent cannot confidently pin down what object is actually being assessed.

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 this rather than `assess_counterparty_risk` for agent verdict, not counterparty risk. That is a concrete alternative and condition. It does not address the other verdict-style siblings, so the exclusion set is only partially covered.

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 read-only, idempotent, non-destructive and closed-world, so safety is covered. The description's real addition is the '$2 USDC' cost and the '46 fields including activity_modifiers, advisory_only' output shape, which are useful call-time facts. It stops short of saying how the answer is scoped (e.g. that `as_of` reproduces a past decision) or what 'advisory_only' implies for acting on the result.

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

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

It is short, and the cost and output-size facts are front-loaded enough to be found. But the phrasing is garbled and run-on ('for bio risk, not bio audit receipt; an object with 46 fields...'), and the negative restatement of the sibling name spends words without adding information.

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

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

An output schema exists, so return values needn't be explained, and the annotations cover the safety profile. Still, for an eight-parameter assessment tool with zero required inputs, the description never says what the assessment decides or how defaults (e.g. `as_of` defaulting to today) affect the answer, leaving the agent to infer the tool's role.

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 eight parameters are already documented and the baseline is 3. The description only names two output fields (`activity_modifiers`, `advisory_only`) rather than explaining any input parameter's meaning or interactions, so it adds no semantic 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 says it is the 'BioRisk' service and explicitly separates it from `create_bio_audit_receipt`, so the agent can tell the two apart. But it never states what the assessment actually produces conceptually (a risk score, a verdict, a decision?) beyond naming two output fields, so the verb+resource pairing stays vague.

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 one explicit routing rule — prefer this over `create_bio_audit_receipt` for bio risk — which is genuine when-to-use guidance. However, there are many other bio siblings (`verify_bio_audit`, `run_bio_verification_checks`, `search_bio_compliance`, `get_bio_catalogue`) and no guidance on when to pick this rather than those, nor any when-not conditions.

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

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

It discloses two things annotations do not: the response shape (an object with 7 fields including detail and error) and a hard cost of $2.5 USDC per call, which matters a lot for call planning. Against that, it never mentions permissions, limits, or that the tool consumes paid balance, and there is a visible tension between a "screen"/return-object framing and the destructiveHint=true, readOnlyHint=false annotations that suggests a charge or side effect the description does not explain.

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

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

It is short and front-loads the purpose, but the text reads as clipped fragments with a dangling quote and an awkward double clause ("business eligibility, not business screen"), so the density costs clarity rather than buying it.

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 10-parameter assessment tool with a full schema, complete annotations, and an output schema, the description supplies the pieces structured fields cannot: the sibling to avoid and the per-call price. Output values need not be explained because an output schema exists. What is missing is what eligibility is judged against, so it falls short of complete.

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

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

Schema description coverage is 100% and every field is documented in the input schema, so the schema already carries full semantic weight and the baseline is 3. The description mentions only turnover and EBITDA and adds no field-level meaning (structure, seller_financing_pct, exit_multiple rules) beyond what the schema states.

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

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

It names the resource (an SME) and a loose verb ("structured screen") over turnover/EBITDA, which is enough to know it is an eligibility assessment rather than, say, a document tool. But the sentence is a fragment ("...on turnover, EBITDA.") and never states the actual verdict/outcome it produces, so the agent learns the inputs screened but not what decision the tool renders.

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 routes explicitly against a named sibling: use this rather than `verify_business_screen` when the goal is business eligibility rather than business screening. That is a concrete alternative-plus-condition. It loses a point only because the caveat "for business eligibility, not business screen" is circular and does not tell the agent what `verify_business_screen` actually returns differently.

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/closed-world, so the description's real contribution is the paid-call disclosure ('$0.5 USDC') and the return shape ('an object with 29 fields'), both of which are behavioral facts an agent needs before calling. No permissions, latency, or failure-mode context is given.

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?

Short and front-loaded on the routing decision, but it contains waste and broken fragments: 'from YOUR OWN.' is truncated, and '29 fields including asOf, as_of' is a redundant restatement that duplicates what the output schema already carries.

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 output schema exists, so describing the 29-field return object is unnecessary, while genuinely useful gaps remain: what an 'identifier' should be (agent id, host, endpoint), whether observations are required to get a meaningful answer, and what happens with the default empty as_of. For a 0-required-param, all-optional tool the description should clarify what a valid call looks like.

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 schema descriptions for identifier and observations are boilerplate ('The identifier this operation operates on'), so the schema does not fully explain them either. The description mentions asOf/as_of, but those are output fields rather than parameters, so it adds nothing for the three inputs. 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 verb ('price the risk') and resource ('paying an unknown agent, endpoint or host'), and explicitly contrasts itself with assess_agent_verdict. The phrase 'from YOUR OWN' trails off and never resolves, leaving the perspective/scope slightly garbled, which keeps it from 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?

Names the alternative assess_agent_verdict and the condition that selects it ('for counterparty risk, not agent verdict'). It does not route against the many adjacent siblings (assess_endpoint_verdict, assess_service_verdict, get_counterparty_preflight/verify_counterparty_preflight), so the coverage of alternatives is partial.

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 (read-only, idempotent, non-destructive), so the description adds genuinely new operational facts: a $0.2 USDC cost and the presence of severity levels like CRITICAL and HIGH. It does not describe rate limits or error behavior, and the output-shape remark is partly redundant with the existing output 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?

Very short and front-loaded, which is good, but the second sentence is syntactically broken and interleaves the routing advice, the return-shape remark, and the price in a way that forces re-reading. Compression has cost clarity here.

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?

Annotations cover safety and an output schema exists, so those burdens are lifted. However, for a paid risk-analysis tool with two loosely documented parameters, the description leaves gaps on supported ecosystems, the dependency entry format, and what the caller actually receives beyond field count.

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 nominally 100%, so the baseline of 3 applies, but the schema text itself is generic boilerplate ('See the schema for its type'). The description adds nothing about what 'ecosystem' values are accepted or what a dependency entry looks like, so it neither helps nor harms.

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: risk analysis of a dependency set within an ecosystem. It also names one sibling it is not (assess_tool_permission), though the crowded 'assess_*' family is only partially disambiguated.

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 this rather than assess_tool_permission when the subject is dependency risk rather than permissions. The phrasing is garbled ('for dependency risk, not permission') and no preconditions or other alternatives are mentioned, keeping it below 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?

Annotations already declare this read-only, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds genuinely new context the agent cannot get from annotations: a $0.02 USDC per-call cost and a rough shape of the payload (52 fields including algorithm and as_of). It loses a point because 'pay me' is never defined and there is no note on what happens when the answer is negative.

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?

Very short and front-loads the purpose question, but the phrasing is a fragment-riddled run-on ('...?. use it rather than...; an object with 52 fields...'). It is compact without being well structured; the cost figure is buried at the end rather than surfaced.

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, and the description still gives cost, an alternative, and payload size. For a 3-parameter read tool this is nearly sufficient; the missing piece is a plain statement of what 'pay' and 'verdict' mean in this x402-style context.

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 url, window_hours, and expected_price_usd are already documented in the schema. The description adds no semantics about how window_hours interacts with expected_price_usd or how they affect the verdict, 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 question 'Will this URL pay me if I call it?' conveys a specific verb+resource (assess whether an endpoint is a paying counterparty) and explicitly distinguishes itself from assess_service_verdict. It falls short of 5 because it names only one of several near-identical assess_*_verdict siblings and never states plainly what a 'verdict' contains.

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: use this rather than `assess_service_verdict` when you want the verdict specifically. No negative case or prerequisite is stated, and the other verdict siblings (assess_tool_verdict, assess_agent_verdict) go unaddressed, so it stops short of a full when/when-not matrix.

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 read-only, idempotent, non-destructive, closed-world behavior, so the description does not need to repeat safety characteristics. It adds a meaningful behavioral detail: the call costs $0.25 USDC. The return-field note is less useful because 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?

The description is short and front-loads the purpose, but structure is rough: 'grant?.' followed by a lower-case sentence, plus an output-shape note that is redundant given the output schema. The price and sibling distinction earn their place; the 38-field note is less clearly useful.

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 assessment tool with full schema descriptions, annotations, and an output schema, the description supplies the key missing context: the tool's domain, the sibling it replaces for tender checks, and the per-call cost. It is complete enough 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 100%, so the input schema already documents all five parameters. The description mentions applicant_id but does not add parameter semantics beyond the schema, and the mention of comparator appears to concern output rather than inputs.

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 decision verb and resource: whether an applicant is eligible for a grant. It also explicitly distinguishes this from tender eligibility, so an agent can identify the correct 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?

It names `assess_tender_eligibility` as the alternative and gives the condition: use this for grant eligibility, not tender eligibility. This is clear routing guidance, though it does not mention nearby eligibility siblings such as `assess_business_eligibility` or any prerequisites.

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

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

It contributes two genuinely useful facts annotations don't carry: the result is a signed, dated certificate, and the call costs $5 USDC. However, annotations declare destructiveHint=true and readOnlyHint=false, and the description frames this as producing a certificate with no mention of any state change or destructive effect, leaving the agent unable to reconcile the two.

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

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

The content is short but structurally broken: the first sentence is a sentence fragment and the uses of 'it' have no antecedent. The key routing information is buried in a run-on clause after the broken 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 shape need not be explained, and cost plus certificate nature are covered. But for a tool annotated destructive and non-idempotent, the description says nothing about side effects, repeat-call behavior, or what mandate/portfolio inputs are required — leaving real gaps.

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

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

Schema description coverage is 100%, including the important 'as_of' reproducibility note, so the schema already carries parameter meaning. The description adds nothing about mandate, portfolio, or observations; 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 names the domain (mandate compliance) and says it returns a signed, dated compliance certificate, which an agent can connect to the tool name. But the opening sentence is a broken fragment ('an allocator can actually.') so the actual action — assess a mandate against a portfolio and observations — is never stated cleanly.

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 away from a sibling: 'use it rather than `assess_spend_anomaly` for mandate compliance, not spend anomaly.' That is a direct when-to-use / when-not-to-use signal. It gives no other prerequisites or context about when a compliance assessment is warranted.

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 closed-world, so safety is covered. The description adds real value beyond that: the result is signed and dated, contains 24 fields (adx, as_of named), and costs $0.05 USDC. Pricing and output-shape hints are exactly the context an agent needs before calling.

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

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

It is short and front-loaded, but the sentence is a run-on stitched together with a semicolon and a bare '$0.05 USDC' fragment. Every clause earns its place, yet the punctuation makes the routing clause easy to misparse.

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?

Output schema exists, so return values need not be spelled out, and the description still names the field count and examples. With all parameters covered by the schema and pricing disclosed, an agent has enough to call this correctly. A note on what 'regime' values are possible would round it out.

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 as_of, method and series. The description adds no parameter-level meaning; the as_of mention refers to an output field, not the parameter. 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 action and resource: returns a single signed, dated market regime read. It explicitly distinguishes itself from assess_portfolio_risk, so an agent can route correctly. 'Regime read' is slightly jargon-y but the domain is 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?

Gives an explicit routing instruction: use this rather than assess_portfolio_risk for market regime, not portfolio risk. That names the alternative and the selecting condition. It does not say when a regime read is unnecessary or what other siblings cover adjacent questions.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so safety is covered. The description adds two useful behavioral facts — the response shape ('an object with 38 fields including after, baseline_recorded') and a cost ('$0.1 USDC') — but says nothing about what happens when no baseline exists or how drift is judged.

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

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

It is short, but the opening is a garbled sentence fragment with a stray '?.' and the content is not front-loaded — the useful routing instruction is buried mid-string. Brevity here reflects poor structure rather than disciplined concision.

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 rich annotation set, 100% schema coverage and an output schema, the description needn't explain returns or safety. It still leaves the core concept (what 'behaviour drift' is measured against, e.g. a baseline) under-specified for a tool with 8 optional 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?

Schema description coverage is 100%, so the schema already documents all 8 parameters (payload, endpoint, observer, price/latency tolerances, etc.). The description adds no parameter meaning beyond that, which is acceptable given the coverage but earns no bonus.

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 name and title are specific (assess operation behaviour drift), and the description explicitly separates this from `check_operation_idempotency`. However, the opening fragment 'Still up — but behaving the same?' only gestures at what drift means rather than stating the verb+resource outcome, so an agent must infer the actual assessment from the tool name.

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 the alternative ('use it rather than `check_operation_idempotency`') and states the selecting condition ('for operation behaviour drift, not operation idempotency'). That is a genuine when-to-use routing instruction, though it lacks any when-not/prerequisite 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?

Annotations already declare this a safe, idempotent, non-destructive read, so the description doesn't need to re-state safety. It adds genuinely new behavioral context: a per-call cost of $3 USDC and a hint at the (large) response shape, both of which matter for invocation decisions.

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

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

It is short and the routing rule is near the front, but the fragment 'an object with 70 fields including asOf, as_of' is garbled and partly redundant. The opening lacks a verb, making it feel like notes rather than a definition.

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 full parameter coverage, the essentials are covered, and cost is a useful addition. However, 'named model' sits awkwardly against a schema that types model as a free-form object, leaving the most consequential parameter's expected shape under-explained.

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 as_of, model, and positions are already documented. The description only echoes 'named model' and 'set of positions' without adding format, constraints, or examples; 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 names the resource and scope precisely ('Risk for a set of positions under a named model') and explicitly distinguishes it from the nearest sibling, assess_pretrade_risk. It lacks an explicit action verb, but the operation is still unambiguous.

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

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

It gives an explicit routing rule — use this instead of assess_pretrade_risk for portfolio risk, not pretrade risk — which is exactly the disambiguation an agent needs with 100+ siblings. It stops short of stating other preconditions or when-not-to-use cases beyond that one sibling.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world behavior. The description adds useful context about the decision outcomes (approve/reduce/reject) and return shape ('46 fields including actual, approvedChecks'), though the output schema makes the field summary partly redundant.

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-loads the core purpose, but it contains a broken clause ('against the risk limits you.') and a semicolon splice into an output summary. Some of the trailing output detail is redundant because an output schema already exists.

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 output schema, full parameter schema coverage, and annotations that cover safety and idempotency, the description is mostly complete. The malformed risk-limits clause and lack of guidance on nullable inputs are minor gaps for a read-only assessment 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 100%, and the schema documents all five inputs including `as_of`, `order`, `limits`, `account`, and `positions`. The description adds no parameter-level meaning, so the 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?

States a specific decision function — an order gate that approves, reduces, or rejects an order against risk limits — and distinguishes pretrade risk from portfolio risk. However, the clause 'against the risk limits you.' is malformed, and the core verb is framed as outcomes rather than 'assess', leaving slight 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?

Explicitly tells the agent to use this tool rather than `assess_portfolio_risk` for pretrade risk, not portfolio risk. This is a clear routing rule with a named alternative and a stated condition, so the agent does not need to infer the correct sibling.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), and the description adds genuinely new context: the result is signed and dated, a single matrix is returned, and the call costs $0.1 USDC — a payment trait no annotation conveys. It stops short of saying whether reproducibility depends on as_of or what 'signed' attests to.

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?

Compact and front-loaded: purpose first, then sibling routing, then output shape and price. The semicolon-clause 'an object with 27 fields including a, as_of' is awkward and truncated, slightly undercutting the structure.

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 the field enumeration is redundant but harmless; the cost disclosure and sibling routing are the pieces an agent actually needs. What 'overlap' measures and how threshold alters the matrix is left implicit, but the schema carries those 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?

Schema description coverage is 100%, so as_of, threshold, and strategies are already documented in the schema, including as_of's reproducibility use. The description mentions as_of only as an output field, adding nothing about threshold semantics or what strategies overlap is measured against. 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 concrete verb and resource ('Return ONE signed, dated overlap matrix') and distinguishes itself from the sibling it is most likely confused with, assess_market_regime. The trailing 'including a, as_of' field list is garbled and adds noise rather than 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?

Explicitly names the alternative (assess_market_regime) and the condition that selects this tool instead ('for quant overlap, not market regime'). An agent can route between the two without opening either schema.

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 non-destructive behavior, so the safety profile is covered. The description adds genuinely new behavioral context: the answer is signed and dated, it costs $0.05 USDC (material for budget-aware agents), and the payload is a large object of ~50 fields. It loses a point because 'E0, N' is unexplained jargon an agent cannot act on.

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 with the purpose front-loaded, so it is appropriately sized. Structure is loose, though: the alternative comparison, the field-count note, and the price are stitched together with semicolons and a stray '$0.05 USDC' fragment, and 'risk of ruin' is repeated redundantly.

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 enumerate return values, and the cost plus signed/dated note covers the commercial and integrity side. But with 8 parameters and 0 required, the description never says what happens when trades/capital/win_rate and friends are omitted, and the cited E0/N fields are uninterpretable.

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 nominal baseline is 3. The description contributes no parameter guidance at all, and the schema's own parameter text is generic boilerplate ('The trades this operation operates on...'), so the description had room to compensate and did not. It does not clarify what happens when the nullable inputs are omitted.

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 concrete verb and resource ('Return ONE signed, dated risk-of-ruin answer') and immediately distinguishes the output from the sibling tool's output ('risk of ruin, not portfolio risk'). An agent can tell this apart from assess_portfolio_risk without opening either schema.

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

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

It names an explicit alternative and the condition that selects it: use this rather than `assess_portfolio_risk` when the question is risk of ruin. That is strong routing guidance. It stops short of covering the many other assess_* siblings or stating when this tool should not be used at all, so a 4 rather than 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?

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds real value beyond that by disclosing the cost ($0.02 USDC) and the shape of the response (56 fields including algorithm, as_of). It stops short of saying how payment is settled, whether results are cached, or what happens on an unknown service.

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

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

It is short and front-loads the core question, which is good. The structure is a run-on of three clipped fragments separated by a semicolon and stray punctuation ('?.', lowercase 'use'), which reads as notes rather than a specification and slightly obscures the cost and return-value facts.

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 does not need to enumerate the 56 fields, and its mention of algorithm/as_of is a helpful pointer rather than padding. Annotations cover safety, and cost is disclosed. The remaining gap is input selection — nothing tells the agent whether to pass a URL, a service name, or both.

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

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

Schema coverage is 100%, so both parameters are documented in the schema, and the description adds nothing about which of url or service_name drives the lookup or how they interact when both are null (both are optional). Baseline 3 is appropriate when the schema carries the load, but the boilerplate schema text ('See the schema for its type and whether it is required') leaves the description with an opportunity it does not take.

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

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

The opening question ('Is this listed service alive, honest and fairly priced?') gives a concrete verdict target and three evaluation axes, and it explicitly names the sibling it is not (assess_endpoint_verdict). 'Listed service' is left undefined, which keeps it slightly short of a fully specific verb+resource statement.

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 supplies one routing rule — prefer this over `assess_endpoint_verdict` when you want a verdict specifically — which is genuinely useful. But there is no guidance on when the tool is inappropriate, what a 'listed service' prerequisite means, or whether url vs service_name should be supplied; usage is only partially 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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds a real behavioral fact not in the structured data — the $0.05 USDC cost — but the 'object with 53 fields including agentId, agent_id' fragment is opaque and adds no usable behavior context.

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

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

The intent is front-loaded in the first clause, but roughly a third of the text is a broken fragment ('an object with 53 fields including agentId, agent_id') that duplicates the same field name in two casings and contradicts the presence of an output schema. Size is fine; the content is not clean.

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?

Read-only judgment tool with an output schema and full parameter coverage, so return values need not be explained. However, nothing says how the verdict is derived from `baseline` versus `spend_window`, and the stray '53 fields' claim may mislead about the return payload the output schema already defines.

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 `agent_id`, `baseline` and `spend_window` are already documented. The description contributes nothing about what a baseline must contain or how the spend window is evaluated, so it sits at the baseline 3 rather than above 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 ('Judge whether the spend is normal') and explicitly separates itself from the `assess_mandate_compliance` sibling. The word 'normal' is left undefined and the surrounding fragments are ungrammatical, but an agent can still tell what domain the tool covers.

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 names the alternative to avoid ('use it rather than `assess_mandate_compliance` for spend anomaly, not mandate compliance'), which is exactly the routing signal an agent needs among ~140 siblings. It stops short of describing prerequisites or when a verdict is inconclusive, but the key exclusion is 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?

Annotations already declare readOnlyHint, idempotentHint, closed-world and non-destructive, so the safety profile is covered. The description adds information the annotations do not: this is a metered call costing '$10 USDC' and it returns a wide object with a `_diagnostics` field and `alphaAfterCostsBps`. That pricing disclosure is materially useful for an agent budgeting calls, though it could say more about what the 98 fields represent.

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 second sentence is a run-on that jams sibling routing, return shape and price together behind a stray '?.' and an awkward 'not market regime' restatement. Everything is relevant, yet the packing hurts scannability.

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, annotations covering safety, and full parameter coverage, the description only needs to add the non-structural facts — it supplies the price and a hint at the output fields, which is enough for an agent to decide and call. Missing only guidance on prerequisites for the market/capital/strategy objects.

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% across the four parameters (as_of, market, capital, strategy), so the schema carries the semantics. The description contributes nothing about what `capital` or `strategy` accept or how `as_of` enables reproducing a past answer, leaving the baseline of 3 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 opening question 'How much money can this strategy actually carry?' identifies the specific resource (strategy capacity / max deployable capital) and the follow-up explicitly separates it from `assess_market_regime`. It is unambiguous what the tool computes, though it states the purpose as a question rather than a verb+resource phrase.

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 the alternative (`assess_market_regime`) and the exclusion condition ('for strategy capacity, not market regime'), which is real routing guidance. It stops short of saying when in a workflow capacity assessment is warranted (e.g., before sizing or allocation), so it is clear context rather than a full when/when-not rule.

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