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 behavior, so the bar is low, but the description adds no behavioral context beyond that: no auth/permission requirements for the caller, no scope of what is audited, and nothing about idempotency or side effects. The only behavioral-adjacent sentence ("an object with 3 fields including ok, results") restates return shape that the output schema already provides.

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 order is wrong: the leading sentence is motivational framing rather than the tool's function, and the second sentence is a run-on that repeats itself ("permission audit, not remediation report"). Conciseness is fine; front-loading 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?

With three loose parameters, an output schema, and rich annotations, the description should at minimum say what an agent permission audit examines and how the permissions input is used. It instead spends its words on a rationale and a return-shape restatement, leaving the agent to infer the tool's scope from the name and the endpoint path in the schema descriptions.

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 reported at 100%, so the schema is the primary carrier and a baseline 3 applies. The description mentions none of the three parameters (task, subject, permissions) and adds no meaning about how permissions are supplied or what a task/subject scoping means.

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

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

The description opens with a rationale ("An over-granted scope is the precondition for every privilege-escalation") rather than a statement of what the tool does; the actual function is only implied by "permission audit" in the routing clause. It does distinguish itself from agent_remediation_report, but the verb+resource core is inferred from the name rather than stated.

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?

"use it rather than `agent_remediation_report` for permission audit, not remediation report" gives an explicit sibling exclusion and the condition that selects this tool. It stops short of stating prerequisites or when the audit itself is inappropriate, so it is clear context without full when/when-not 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 readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely useful context beyond them: the cost ($0.75 USDC) and the shape of the return (an object with 13 fields including files and findings). It does not describe latency, failure modes, or what happens with empty findings.

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 mostly front-loaded, but the phrasing is garbled: a lowercase mid-sentence 'use it rather than...' clause and a price tag tacked on at the end after the return-shape note. The information is there but the ordering and grammar weaken scanability.

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 need not explain return values, and it correctly leaves that to the schema while adding cost and output field count. For a 10-parameter generative reporting tool, the missing pieces (parameter meaning, edge cases for empty inputs) are moderate rather than fatal.

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?

Nominal schema coverage is 100%, but the per-parameter descriptions are boilerplate endpoint strings ('[POST /v1/security/remediation]') that convey no meaning about task, text, prompt, subject, permissions, or tool_definitions. The description only names two of the ten parameters (files, findings), so it adds little beyond the surface 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 concrete verb+resource: turning an agent's security findings into an actionable fix list, and explicitly contrasts itself with `agent_permission_audit`. However, the far closer sibling `build_remediation_plan` is not mentioned, so an agent still has to guess between two remediation-oriented tools.

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

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

Gives an explicit routing rule: use this rather than `agent_permission_audit` for a remediation report, not a permission audit. That is clear context for the alternative, but no prerequisites, input expectations, or guidance versus `build_remediation_plan` are given.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the bar is lower. The description still adds genuinely new context: the report is signed, returns an object with 12 fields, and costs $2 USDC — cost and output shape are not in the annotations. The "12 fields including files" claim is oddly specific but unverifiable.

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?

A single run-on sentence stitched from fragments ("run the full agent", "ok.", stray semicolons) that reads as concatenated template output. Nothing is front-loaded into scannable clauses, and parts of it do not parse as English.

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?

Missing: 14 optional parameters that silently fan out to three different security endpoints (prompt-injection, agent-scan, secret-exposure), with no guidance on which subset to populate. An agent could call this with zero arguments and have no idea what would actually be scanned. The output schema offsets the return-value gap, but not the input-selection gap.

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

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

Schema coverage is nominally 100%, but the parameter descriptions are only endpoint paths like "[POST /v1/security/agent-scan]", which convey little meaning. The description names only one field ("files") out of 14 and does not explain the assessment.* / prompt.* / credentials.* groupings that map to three distinct sub-scans. Baseline 3 applies when the schema nominally documents the parameters.

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 clause gives a specific verb and resource: "Assess an agent's security posture in one signed report." It also names the sibling it must not be confused with (assess_agent_verdict), which is real differentiation. The clarity is dented by the non-parsing fragment "run the full agent," but the core purpose is still recoverable.

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

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

Explicit routing instruction: "use it rather than `assess_agent_verdict` for security assessment, not agent verdict." That names the alternative and the selection condition. No exclusions or prerequisites are given beyond that, and the garbled phrasing weakens an otherwise clean rule.

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, non-destructive and closed-world, so safety is covered. The description adds genuinely useful non-schema context — a $1.5 USDC price and a partial return shape — but the sentence is truncated, so no detail on what the three surfaces actually check or how findings are reported.

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 text is a truncated, grammatically broken fragment with an orphaned price suffix ('$1.5 USDC'). The routing guidance is buried mid-string rather than front-loaded, and a dangling clause wastes space.

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 explained, and annotations plus full schema coverage cover safety and inputs. What is missing is the one thing only the description can supply: a coherent statement of what the three attack surfaces are and what an 'ok' verdict means.

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 of 3 applies; each parameter is tagged with its backing endpoint. The description's fragment about 'what the agent reads' gestures at the input surfaces but adds no format or content guidance 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 opens with 'The three attack surfaces' and trails off mid-clause ('what the agent reads, what the agent.'), so the specific verb and full scope are never completed. The name and title carry the rest, and the sibling reference clarifies what it is not, but the core purpose statement is broken.

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 it rather than `agent_permission_audit` for threat assessment, not permission audit.' That is a concrete when-to-use/when-not-to-use pair against a named sibling. It stops short of covering the many other adjacent security siblings (scan_prompt_injection, audit_tool_poisoning, agent_security_assessment).

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, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds a cost signal ('$29 USDC') and a partial return-shape hint, but it does not explain payment mechanics, authorization, or other operational 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?

It is short and front-loaded, but the phrasing is choppy and repetitive, and the return-value sentence is incomplete ('3 fields including content, content_type' names only two). The output schema already covers return 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?

For a zero-parameter, read-only tool with an output schema, the description covers purpose, sibling exclusion, and cost. It could say more about payment handling, but the core information needed to select the tool is present.

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

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

The tool has zero input parameters, so the schema baseline is 4. The description does not need to explain parameter semantics.

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

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

The description identifies the resource and action as 'Ebook Download' and explicitly distinguishes it from the sibling `agent_security_assessment`. It is not a polished verb+resource phrase, but an agent can still tell what the tool is for.

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

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

It gives a clear routing instruction: use this rather than `agent_security_assessment` for ebook download, not security assessment. The guidance is explicit but limited to one alternative and does not elaborate broader when/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?

Annotations already cover the safety profile (read-only, idempotent, non-destructive, closed-world), and the description adds genuinely new facts: it operates on a supplied wait-for graph and returns an object with 30 fields including `action` and `acyclic`, plus a $0.1 USDC cost. The pricing and result-shape disclosures are the kind of context 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?

The first sentence is well front-loaded, but the remainder is a garbled run-on that jams usage routing, a return-shape summary, and a price into one semicolon-joined clause. It is short but not cleanly structured.

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

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

Safety and return values are covered by annotations and the output schema, and both parameters have schema text. What is left unexplained is the shape of the wait-for edges themselves, the single thing an agent most needs to construct a valid 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 100%, so both parameters are already documented at baseline. The phrase "supplied wait-for graph" hints that `wait_for_edges` carries the graph structure, but it does not clarify the edge object format, which matters because `items` is an untyped `{}`.

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: "Detect a deadlock in a supplied wait-for graph." It explicitly contrasts itself with the nearest sibling, `assess_operation_behaviour_drift`, so an agent can distinguish the two without opening either schema.

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

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

Gives an explicit routing rule: use this rather than `assess_operation_behaviour_drift` for agent deadlock, not operation behaviour drift. That is a clear use-case plus named alternative, though it only names one sibling and offers no other preconditions or exclusions.

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

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

Annotations already declare this a read-only, idempotent, non-destructive closed-world operation, so safety is covered structurally. The description's genuine addition is the cost disclosure ('$0.02 USDC'), which matters a lot for a paid call, but it does not say how payment is transacted, whether the call fails without funds, or what a 'safe' vs 'unsafe' result looks like behaviorally.

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 front-loaded question is good, but the remainder is a garbled run-on ('use it rather than `agent_security_assessment` for agent verdict, not security assessment; an object with 30 fields...') with stray punctuation ('right now?.'). The '30 fields including address, algorithm' fragment is filler when an output schema already exists, so the text is short but not efficient.

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

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

An output schema exists, so return values need not be described. Still, for a paid, verdict-returning tool the description omits what a verdict contains semantically (thresholds, confidence, verdict categories), how the $0.02 USDC charge is settled, and how the optional chain argument changes the assessment — and it leaves the wallet-vs-agent ambiguity unresolved.

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

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

Schema description coverage is 100%, so the two parameters (address and optional chain) are already documented, making 3 the baseline. The description adds no meaning beyond the schema — the mention of 'address' describes the response object, not the input, and the optional chain parameter is never explained (e.g. default chain behavior).

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 leading question 'Is this wallet safe to transact with right now?' gives a rough sense of intent, and the name plus 'agent verdict' identifies the resource. But the description never says plainly verb+resource ('returns a verdict on whether an agent is trustworthy'), and it conflates the target of assessment — the question asks about a wallet while the tool name says agent verdict. An agent has to reconcile two different framings to know what it is actually assessing.

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 does explicitly name one alternative, `agent_security_assessment`, and says to use this tool rather than that one 'for agent verdict, not security assessment'. That is a real routing instruction. However, the enormous sibling set includes many near-identical verdict tools (assess_tool_verdict, assess_endpoint_verdict, assess_service_verdict, agent_permission_audit) that are not addressed, and the 'not security assessment' phrasing is grammatically ambiguous about what is excluded.

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 readOnly, idempotent, non-destructive, closed-world, so the bar is lower. The description adds a real behavioral trait the schema cannot: a cost of '$2 USDC'. The '47 fields including activity_modifiers, advisory_only' note is largely redundant given an output schema exists, and nothing is said about what decision the assessment yields or its advisory-only implications.

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 structure is awkward: a service label, a mangled comparative clause ('for bio risk, not bio audit receipt'), and a stitched-on output/cost note. The most important fact (paid call, $2 USDC) is buried at the end rather than front-loaded.

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

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

For a read-only assessment with an output schema and full schema coverage, most needs are met by structured fields, and cost plus sibling routing are present. What is missing is the substantive payload: what risk output/verdict an agent should expect and what 'advisory_only' means for acting on 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 parameter meaning is fully carried by the schema; baseline 3 applies. The description only echoes activity_modifiers and adds no syntax, constraints, or defaults 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?

The name assess_bio_risk plus the fragment 'BioRisk' implies a bio risk assessment, but the description never states a verb+resource clearly — 'BioTrust Service 01 — BioRisk' is a service label, not a purpose statement. It does distinguish itself from create_bio_audit_receipt, which helps differentiation, but the core 'what does assessing produce' is left to the 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?

Explicitly says to use this rather than `create_bio_audit_receipt` 'for bio risk, not bio audit receipt', giving a concrete alternative and selection condition. No exclusions beyond that, and the phrasing is garbled, but the routing intent is unmistakable.

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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety behavior is covered. The description adds the concrete pricing ($0.2 USDC), which is useful, but it does not mention rate limits, auth needs, or behavior with empty/omitted parameters. The '42 fields including CRITICAL, HIGH' detail is output information already available via the 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?

The description is short and front-loads the purpose, but it is written as fragmented clauses with a lowercase sentence start and semicolon splice. The output-field detail is redundant given the output schema, and the price is tacked on rather than integrated.

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 simple two-parameter, read-only shape, rich annotations, and an output schema, the description covers purpose, sibling routing, cost, and severity labels. It still leaves unclear what happens when both optional parameters are omitted or what 'mixed' ecosystem means, but those gaps are modest for this tool.

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

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

Schema coverage is 100%, so the schema is the primary source for the two optional parameters, and the baseline is 3. The description maps the parameters conceptually ('dependency set for a given ecosystem') but adds no format or value details beyond that, and the schema descriptions themselves are generic boilerplate.

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

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

States a specific resource (dependency set) and domain (given ecosystem), making the tool's target clear. It explicitly distinguishes itself from `agent_permission_audit`, though 'risk analysis' remains slightly vague about the exact risk type (security, license, maintenance).

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?

Directly tells the agent to use this rather than `agent_permission_audit` for dependency risk and not permission audit. This is an explicit when-not and alternative naming, which is exactly what routing guidance should do.

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, so safety is covered. The description adds genuinely new behavioral context by stating the operation costs $1 USDC, but the payoff sentence ('an object with 29 fields including amount_field, artefact_count') duplicates the output schema rather than explaining the grading behavior or what the grade means.

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 run-on fragments crammed into two lines, mixing purpose, sibling routing, return-field enumeration and pricing with no front-loading or sentence structure. The backticked tool name mid-sentence and the trailing '$1 USDC' read as appended metadata rather than prose.

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 annotations carry the safety profile. What's missing is the substantive piece: with two optional parameters (including an unbounded nested `record`), the description never says what input is actually required to run a grading, nor what the grade or the amount_field/artefact_count drive.

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

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

Schema description coverage is 100%, so both parameters are documented structurally and the baseline of 3 applies. The description adds nothing about how `record` and `dispute_id` relate or which one to supply — a real ambiguity given both are optional and `record` is a free-form nested object.

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 pair ('Assemble and grade the evidence') and names the sibling `build_dispute_counterparty_record` as the wrong tool for this job, which lets an agent separate the two without opening schemas. The resource is only named indirectly via the sibling contrast rather than stated plainly as dispute evidence, 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?

It explicitly routes the agent: use this for dispute evidence, not the dispute counterparty record. That is a real when-to-use/when-not pairing against a concrete alternative, though the phrasing is garbled and it gives no prerequisites or ordering relative to the other dispute tools (create_dispute_ruling, verify_dispute_ruling, ingest_evidence).

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?

Annotations already declare destructiveHint=true, readOnlyHint=false, and non-idempotent, so the safety profile is carried structurally. The description adds genuinely useful context — a $5 USDC cost and a 32-field output shape — but never explains why a read-looking assessment is flagged destructive or whether the charge is incurred on failure.

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 malformed: the first sentence breaks off mid-clause and two fragments ('an object with 32 fields including actual, asOf. $5 USDC.') are spliced in without connective structure. Brevity without coherence does not earn credit for 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 return values need not be spelled out, and the description correctly points to the cost and the sibling alternative. However, for a no-required-param tool flagged destructive, the description never says what happens when mandate/portfolio/observations are omitted, leaving a real gap for correct invocation.

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

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

Schema description coverage is 100%, so the four parameters (as_of, mandate, portfolio, observations) are already documented, including the reproduce-a-past-answer semantics of as_of. The description only names output fields (actual, asOf) rather than adding meaning to any input parameter, so baseline 3 applies.

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

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

The description names the artifact produced (a signed, dated compliance certificate) and explicitly scopes it to mandate compliance rather than spend anomaly, so an agent can distinguish it from assess_spend_anomaly. The broken sentence ('an allocator can actually.') and the fact that it describes the output rather than the verification action keep it below 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?

Explicit routing is present: 'use it rather than `assess_spend_anomaly` for mandate compliance, not spend anomaly.' That names the alternative and the selecting condition. No prerequisites (auth, required inputs) are stated, which prevents 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 read-only, idempotent, non-destructive, and closed-world behavior, so the safety profile is covered. The description adds meaningful context beyond annotations: the result is signed, dated, a single regime read, includes 28 fields such as `adx` and `as_of`, and costs $0.05 USDC. It does not discuss auth or rate limits, but the cost and signed-output disclosure is substantive.

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

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

The description is short and front-loaded: purpose first, sibling differentiation second, output/cost details last. Every phrase carries useful selection or invocation information, with no filler.

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

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

Given an output schema, annotations, and 100% schema coverage, the description supplies the remaining decision-relevant details: it is a single signed/dated regime read, distinct from portfolio risk, with a known field count and price. Nothing critical for correct selection or invocation appears 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 parameters are already documented in the schema, and the description does not add meaning for `method` or `series`. Its mention of `as_of` is framed as an output field rather than explaining the parameter's reproducibility behavior beyond what the schema already 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?

The description gives a specific verb and resource — "Return ONE signed, dated regime read" — and explicitly distinguishes it from `assess_portfolio_risk`. An agent can identify it as a market-regime assessment rather than a portfolio-risk tool 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 explicitly says to use this rather than `assess_portfolio_risk` for market regime, not portfolio risk, giving a clear alternative and scope condition. It does not address other market-data siblings such as `get_market_snapshot` or `get_market_history`, so the routing guidance is clear but not exhaustive.

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, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds a real behavioral fact not in annotations — the '$0.1 USDC' cost — but the '38 fields including after, baseline_recorded' claim largely duplicates the existing output schema rather than adding 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?

It is short, but the structure is fragmented and awkward: a cryptic rhetorical question, a run-on clause with a stray semicolon, and a dangling price fragment. The '38 fields' sentence duplicates the output schema and does not clearly 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?

For an 8-parameter assessment tool with tolerance inputs and an output schema, the description is thin. It never explains what drift detection compares (baseline vs. observed price/latency?), how tolerances affect the outcome, or what a positive drift signal means — leaving an agent to infer the tool's core behavior from parameter names.

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 mentions no parameters and adds no semantics beyond what the schema provides, making the baseline 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 description names the resource ('operation behaviour drift') and explicitly distinguishes it from the sibling assess_agent_deadlock, which helps. However, the opening 'Still up — but behaving the same?' is cryptic and the description never states what the tool actually produces (a drift verdict? a comparison report?), so the verb+outcome remain 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 an explicit routing rule: use this rather than `assess_agent_deadlock` for operation behaviour drift, not agent deadlock. That is a concrete alternative and exclusion. It stops short of describing any other preconditions or when-not cases beyond this 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 readOnly/idempotent/non-destructive, and the description adds two things annotations cannot: a monetary cost ($3 USDC) and the shape of the response (an object with 72 fields). The field-count/asOf detail is largely redundant with the existing output schema, but price-per-call is genuinely useful context 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?

It is short and problem-first, but written as sentence fragments with no main verbs ("Risk for a set of positions...", "$3 USDC."), and the trailing "an object with 72 fields including asOf, as_of" is ambiguous — it reads as return-field notes with an apparent duplicate name. Compact, but the missing structure costs clarity.

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

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

An output schema exists, so the 72-field return value needn't be described. However, with zero required parameters and a $3 per-call price, the description should state that `model` and `positions` must actually be supplied and what a null/empty call does. That gap matters more than usual for a paid, silently-defaulting tool.

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

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

Schema coverage is 100%, so `as_of`, `model`, and `positions` are already documented individually. The description only loosely restates that positions and a model are involved and never mentions `as_of` semantics (reproducing a past answer), so it adds little beyond the schema. 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?

It names the resource (risk) and scope (a set of positions under a named model) and explicitly distinguishes itself from `assess_pretrade_risk`, so an agent can separate the two without opening schemas. The phrasing is telegraphic (no verb) and does not distinguish it from other portfolio-adjacent siblings such as `evaluate_portfolio_verdict` or `assess_risk_of_ruin`.

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 rather than `assess_pretrade_risk` for portfolio (not pretrade) risk. That is a concrete when-to-use statement against a named alternative. It stops short of saying when NOT to use it against the other risk-assessment 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 readOnlyHint=true, idempotentHint=true and destructiveHint=false, and the description is consistent with them (it assesses, it does not place the order). It adds the useful outcome vocabulary of approve/reduce/reject, but the "49 fields including _order_symbol, actual" fragment is garbled return-value noise already covered by the output schema. No annotation contradiction.

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 it is not clean: an incomplete sentence ("the risk limits you.") and a dangling output fragment ("an object with 49 fields including _order_symbol, actual") that reads like truncated machine-generated text. The core routing instruction is front-loaded, but the noise undermines 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?

With an output schema present and full annotation coverage, the description needn't explain return structure, and it does supply the key sibling disambiguation. But the corrupted trailing text and the lack of any note on what limits/account/positions must contain leave it only minimally adequate for a 5-parameter decision gate.

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, order, limits, account and positions. The description only gestures at "risk limits" and "order" at a high level and adds no syntax, defaults, or interaction 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 opening clause names a concrete verb set (approve, reduce or reject) and resource (an order against risk limits), and explicitly contrasts itself with `assess_portfolio_risk`. However, the sentence is grammatically broken ("risk limits you.") and the trailing fragment about "an object with 49 fields including _order_symbol, actual" obscures rather than sharpens the purpose.

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

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

It explicitly routes the agent away from the closest sibling: "use it rather than `assess_portfolio_risk` for pretrade risk, not portfolio risk." That is a real disambiguation rule. It stops short of stating prerequisites (e.g. limits/account must be supplied) or when-not conditions beyond the portfolio alternative.

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

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

Annotations already declare read-only, idempotent, non-destructive, closed-world, so the description only needs to add what they cannot. It does: the result is signed and dated, carries 31 fields, and costs $0.1 USDC — the pricing disclosure is genuinely useful context not in structured data. It stops short of explaining what 'signed' guarantees or how billing is settled.

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 before the sibling contrast. The mid-sentence semicolon splice ('...not market regime; an object with 31 fields...') makes the second clause read as a dangling fragment rather than clean structure, costing a point.

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 plus full annotation coverage, the description need not explain return values, and it appropriately adds cost and result shape instead. What remains thin is the meaning of 'quant overlap' and the threshold parameter's effect, but for a single-output computation tool this is close to sufficient.

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

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

Schema description coverage is 100%, so the schema already documents as_of, threshold, and strategies — baseline 3 applies. The description contributes nothing parameter-specific beyond echoing 'as_of' as a returned field, so it neither helps nor hurts.

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 artifact ('Return ONE signed, dated overlap matrix') and immediately contrasts it with the sibling assess_market_regime, so the agent can differentiate. The phrase 'quant overlap' is a bit jargon-y but paired with 'overlap matrix' it is concrete enough to act on.

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 it rather than assess_market_regime for quant overlap, not market regime'. This is a clear when-to-use-this-instead-of-that rule. No exclusions or prerequisites are given beyond that single contrast.

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, closed-world, non-destructive), yet the description adds genuinely new context: the result is signed and dated, it carries a per-call price of $0.05 USDC, and it returns an object with 54 fields including E0 and N. What's missing is any note on how the seed/as_of reproduce an answer or how the charge is incurred.

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 core contract and stays to three short clauses with no padding. The middle sentence is a run-on that muddles the comparison, and 'including E0, N' is cryptic without elaboration.

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 detail isn't required, yet the description still adds shape (54 fields), signing, and pricing. The gap is that all eight inputs are optional with defaults and the description never says a zero-argument call is valid or which inputs actually drive the answer.

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 baseline 3 applies, and the description adds nothing about the eight parameters — no mention of seed/as_of for reproducibility or of trades/capital/win_rate/avg_win_r/avg_loss_r/risk_per_trade_pct. The schema's own parameter text is boilerplate ('See the schema for its type'), so the description could have compensated but doesn't.

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

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

States a specific resource (a signed, dated risk-of-ruin answer) and explicitly contrasts itself with the sibling assess_portfolio_risk, so an agent can pick between them without opening either schema. The 'ONE' emphasis makes the single-answer contract 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?

Names the alternative it replaces ('use it rather than `assess_portfolio_risk` for risk of ruin, not portfolio risk'), which is real routing guidance. However the condition is close to restating the name, and there is no guidance on prerequisites, cost thresholds, or when not to call it.

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

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

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.