site

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

With no annotations, the description carries the full burden and does surface a genuinely important behavioral trait: this is a signature, not a transaction, with no fee and no asset movement. That reassures the agent about side effects. It omits other relevant behaviors such as message expiry, single-use semantics, or what the returned message contains.

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 compact sentences, front-loaded with the action and result, then the safety caveat, then the follow-up call. No filler or repetition.

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

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

For a single-parameter, no-annotation, no-output-schema tool, it explains both the input and the general nature of the return value ('the exact message to sign') and the chaining step. Only minor operational details (session lifetime, signed-message contents) are absent.

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

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

Schema coverage is 0% and the single parameter has no description, so the description must compensate; it establishes that the input is a Solana address, giving the parameter clear meaning. Length bounds (32-44 chars) are left to the schema, which is acceptable since the semantic role is covered.

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 input-output contract ('Give a Solana address; get the exact message to sign'), which is a specific verb+resource rather than a restatement. It also names the sibling agent_session_verify as the next step, letting an agent distinguish the two endpoints without reading 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?

Clearly positions this as the first step of the sign-in flow and tells the agent to follow with agent_session_verify using the base64 signature, which is actionable sequencing. It doesn't state any exclusions or when-not-to-use cases, so it stops short of 5.

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

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

With no annotations, the description carries the full behavioral burden: it does disclose token lifetime (30 days), revocation ('revocable from the account page'), the base64 Ed25519 signature requirement, and the exactness constraint on the message, which are meaningful traits. It stops short of stating the side effect (creating a session), what happens on signature/address mismatch, or any rate/permission constraints, leaving notable gaps for an auth-mutating tool.

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

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

Two compact sentences with the required inputs front-loaded ahead of the return value, and no padding. The opening is a verbless fragment, which slightly reduces readability, but nothing is wasted.

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

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

There is no output schema, so the description correctly describes the return value (a session token to pass as `session`), plus its lifetime and revocability — the essentials for an agent to proceed. It omits failure behavior and the precise meaning of `address`, but for a three-parameter step in a known sequence it is largely 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 0%, so the description must compensate, and it does document the meaning of all three parameters: the message provenance ('exact message from agent_session_start') and the signature encoding ('base64 Ed25519'). The 'address' parameter is named but not explained (presumably the wallet address), and no format/length constraints from the schema are echoed, so it stops just short of full coverage.

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

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

The title supplies the verb ('Finish the wallet sign-in') and the body confirms the outcome ('Returns a session token'), and it explicitly distinguishes itself from agent_session_start, whose message output it consumes. The body sentence itself is a noun-phrase list of inputs rather than a stated verb+resource, so an agent must lean on the title for the action, but the combined definition is 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 implies the correct sequence by requiring 'the exact message from agent_session_start' and by telling the agent to pass the returned token to 'every later call', which is genuine workflow guidance. However, it never states when this tool should not be used, what to do if the message is missing/expired, or any alternative path, so usage is implied rather than explicit.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does disclose one genuinely useful trait — that claimant identity is never returned — plus the fields it does report (proof, timestamp). But it omits that the operation is a read, what happens for unclaimed entries, and anything about 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?

A single tightly written sentence with zero padding, and the most distinguishing clause ('never by whom') is placed at the end as a natural caveat. It is efficient, though brevity here edges toward under-specification rather than economy.

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

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

There is no output schema and no annotations, so the description must do more work. It partially describes the return contents, but leaves both input parameters and the read-only nature unexplained, making it only minimally adequate given the tool's role in a larger claim workflow.

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

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

Schema description coverage is 0% and the description says nothing about 'scheme' or 'value'. These two required, undocumented parameters are the core of the call, and the agent is left to guess the intended identifier format; the description does not compensate for the coverage gap.

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

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

The description conveys the resource and the shape of the answer (whether a claim exists, by which proof, when, but not by whom), which is more informative than a bare name. However, it is phrased as a question with no verb (lookup/check/report), and it does nothing to distinguish itself from the sibling claim_status, which sounds like the same job. An agent cannot confidently route between the two.

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 statement of when to use this tool versus claim_status, claim_verify, or entity_lookup. Only the incidental phrase 'never by whom' hints at a privacy condition, but that is not framed as usage guidance or an exclusion that would steer tool selection.

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

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

With no annotations, the description carries the full burden. It does disclose meaningful output behavior (returns the proof domain and a token, plus the three placement methods: TXT record, well-known file, or verified email), but says nothing about auth beyond session, idempotency, rate limits, or what happens 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?

A single dense sentence with the input and output front-loaded and no filler. Slightly awkward phrasing ('proof domain the register lists') but appropriately sized.

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

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

With no annotations and no output schema, the description is the only source of behavioral info. It covers inputs and outputs well enough, but omits the multi-step claim lifecycle (why a token, how claim_verify follows) an agent needs to use it correctly within the sibling set.

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 33% and only the session parameter is documented in the schema. The description adds partial meaning by explaining that the entry is identified by scheme + value (e.g. 'lei'), but gives no format, constraints, or distinctions for the scheme and value fields themselves.

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

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

The description states a specific action (naming a register entry) and its result (the proof domain and the token to place), which tells an agent this initiates a domain-ownership claim. It is clear enough to identify the resource, but it never explicitly differentiates this from the closely named siblings claim_public, claim_verify, and claim_status.

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

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

There is no statement of when to call this versus claim_public or claim_verify, nor any prerequisite (the session token only being referenced via the schema). The description implies a first step in a flow but never says so, leaving the agent to infer the ordering.

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

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

With no annotations, the description carries the full burden, and it does disclose a useful behavioral trait: instructions are returned conditionally, only while a claim is pending. It says nothing about permissions, session requirements, or whether the result is scoped or exhaustive beyond 'this account.'

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 tight sentence with the resource front-loaded and no filler. The parenthetical 'while pending' clause is slightly tangled but earns its place by signaling conditional content.

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

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

No output schema exists, so the description must cover return values, and it does name what comes back (claims, statuses, pending instructions). For a one-parameter read tool this is nearly sufficient, though it omits collection shape and any result limits.

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

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

There is a single parameter and schema description coverage is 100% — the session token is fully documented as coming from agent_session_verify. The description adds no parameter detail, so the baseline of 3 applies.

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

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

The description names the resource (every claim of this account) and the payload (status and, while pending, instructions), so an agent can tell it retrieves claim state. It does not explicitly distinguish itself from siblings such as claim_start, claim_verify, claim_public, or listing_status, leaving differentiation to inference.

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 when-to-use statement, no prerequisites, and no named alternative. The agent must infer that this is the read-side companion to the claim_* mutation tools; nothing in the text guides that choice.

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

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

No annotations are provided, so the description carries the full burden. It does disclose a useful behavioral trait — that verification involves reading DNS, a .well-known file, and a verified email — and that verified claims become badges on the profile, which hints at a lasting side effect. However it omits whether the call is idempotent, what permissions are needed, and what a partial/failed verification returns.

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 a single compact sentence with no filler, but it is not front-loaded around the action and reads as an aside about server internals rather than a task statement. Adequate but not efficiently framed.

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

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

With no annotations, no output schema, and only 50% parameter coverage, the description should explain the verification outcome (does it mutate badge state? what does the caller get back?) and the required session flow. It leaves the most decision-relevant information implicit.

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

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

Schema description coverage is 50%: the session parameter is documented in the schema, but the id parameter (10-60 chars) is not described anywhere, and the description adds no meaning about what the id identifies (claim, profile, or entity). The description does not compensate for the coverage gap.

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

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

The name and title make the action clear (verify a claim's proof), but the description itself only describes the server-side mechanism — reading DNS, a well-known file and email — without stating the verb+resource directly. It also does not distinguish this tool from close siblings such as claim_start or claim_status.

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

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

There is no guidance on when to call this versus claim_start, claim_status, or claim_public, and no stated prerequisites such as the session token requirement beyond what the schema already says. The agent must infer the workflow ordering.

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

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

With no annotations provided, the description carries the full disclosure burden. It states what is returned, which helps, but never says the operation is read-only, whether it hits the network or a cache, or if it requires an authenticated session. For a zero-param introspection call the risk is low, but the disclosure is thin.

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 payload listed first and the ordering advice second. Nothing is padded or restated from the title.

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

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

With no output schema, the description usefully enumerates the four things returned, and with no parameters there is little else to specify. It stops just short of explaining the provenance banner's meaning or the shape of the column list.

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 takes no parameters, which is the baseline-4 case; there is nothing for the description to clarify beyond confirming the tool is invoked with no arguments.

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

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

Names the concrete resource and enumerates the exact payload: columns, numeric flags, row count, and provenance banner for the Issafu dataset. It is specific, though it does not distinguish itself from siblings like dataset_stats (which likely also reports row counts) or dataset_provenance (which likely returns the same banner).

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?

'Call this first to learn the schema' gives one clear sequencing cue, which is genuinely useful. However, it offers no guidance on when to reach for dataset_stats, dataset_row, or dataset_provenance instead, even though the description's stated return content overlaps with those 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?

No annotations are provided, so the description carries the full burden. It discloses the filtering logic and that output rows preserve the order of the given values, which is a useful behavioral trait. However, it does not state that the operation is read-only, nor does it mention permissions, rate limits, or error behavior, leaving gaps for a tool with zero annotation coverage.

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

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

The description is a single, front-loaded sentence that states the core behavior without extraneous words. The structure is slightly awkward with the em-dash and trailing purpose clause, but it remains concise and readable.

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

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

Given the lack of annotations, no output schema, and 0% schema description coverage, the description is too sparse. It omits parameter details, the 2–10 values constraint, return format, and any behavioral caveats, leaving the agent to infer much of the tool's contract.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It references 'column' and 'given values' and notes that values are used 'in the order given,' but it does not explain what a column identifier looks like, what values represent, or the 2–10 item constraint. This leaves the parameters largely unspecified.

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 operation: retrieve rows of the Issafu dataset where a given column matches any of the supplied values, preserving the order of those values. This distinguishes it from siblings like dataset_search (which likely has different filtering) and dataset_row (single row), though it does not explicitly name those alternatives.

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

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

The phrase 'for "X vs Y" questions' provides clear context for when to use this tool, indicating a comparative scenario. It does not state when not to use it or name alternative tools, but the intended use case is communicated.

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

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

With no annotations, the description carries the full burden. It discloses what metadata is returned (source, date computed, licence, citation), which is the meaningful behavior for a zero-parameter metadata lookup, but says nothing about auth requirements, caching, or whether the values are static. For an inherently side-effect-free read this is adequate, not rich.

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

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

Two sentences, no filler. The returned fields are front-loaded and the imperative 'Read this...' follows immediately, so the agent gets content and purpose in one pass.

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?

No output schema exists, so the description must describe the return values, and it does so by enumerating all four fields. Combined with the absence of parameters, that is nearly everything an agent needs; only the response shape is left implicit.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate. Baseline of 4 applies; no parameter semantics are needed or missing.

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 exact resource (the Issafu dataset's provenance) and enumerates the concrete fields it exposes: source, computation date, licence, and citation. That is specific enough to separate it from siblings like dataset_columns or dataset_stats, though it is a noun list with no verb.

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?

'Read this to attribute a figure correctly' gives an explicit use case that selects this tool over the other dataset_* tools. It lacks any negative guidance or named alternatives, but the trigger condition is unambiguous.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses that matching is exact and case-insensitive, which is a genuine trait beyond the schema. It does not say what happens on zero matches or multiple matches, whether results are capped, or what the response shape is.

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 efficient sentence with the core filtering constraint front-loaded and no filler. It is arguably under-specified for a tool with zero schema documentation, but nothing in it is wasted.

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

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

For a two-parameter lookup with no annotations and no output schema, an agent still doesn't know the return cardinality (one row vs. many), result limits, or behavior on no match. These are exactly the details the description must supply here and doesn't.

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

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

Schema coverage is 0%, so the description has to compensate, and it partially does by naming the roles of both parameters ('a column equals a value'). It adds no format guidance, allowed values, or how column identifiers are resolved against the dataset_columns listing.

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 operation: returning dataset rows where a named column exactly equals a supplied value. Combined with the title ('Look a row up by an exact key'), the retrieval intent is unambiguous. However, it never distinguishes itself from the sibling dataset_search, so an agent must guess which retrieval tool applies.

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 when-to-use or when-not-to-use guidance and no mention of any alternative. The presence of dataset_search and entity_lookup among siblings makes the missing routing guidance a real gap, since 'exact equals' vs. 'search' is exactly the choice an agent needs to make.

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

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

No annotations are provided, so the description carries the full burden. It discloses case-insensitive matching and a 50-row cap (the cap merely restates the schema maximum), but says nothing about read-only nature, permissions, ordering, or what a returned row contains.

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?

One sentence, front-loaded with the resource and matching rule, no filler. Nothing to trim.

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

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

For a simple two-parameter read tool with no output schema, the description covers the matching contract but omits result shape, ordering, and safety/read-only context. Adequate but with visible 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 coverage is 50% (limit is undocumented in the schema). The description adds real semantics for query ('cells contain ... case-insensitive', i.e. any-cell substring match), which the schema does not state, but adds nothing for limit beyond the schema's maximum of 50.

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 clear verb+resource (search rows of the Issafu dataset) plus the matching rule (any cell, case-insensitive) and result cap. It implicitly distinguishes itself from dataset_row, dataset_top and dataset_columns by describing substring matching across cells, though it never names a sibling explicitly.

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

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

There is no guidance on when to use this versus dataset_top, dataset_row, or entities_search. The matching semantics imply a free-text lookup use case, but the agent must infer when this is the right 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?

No annotations are provided, so the description carries the full disclosure burden. It usefully discloses real behavioral traits: grouping commas and currency symbols are parsed, and non-numeric rows are excluded and counted. It does not cover error behavior (e.g., an entirely non-numeric column), authentication, or the meaning of the returned count relative to total rows.

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 sentence that front-loads the returned metrics and tucks the parsing/edge-case caveats into a parenthetical. Nothing is wasted, though the parenthetical is slightly dense.

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

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

With no output schema present, the description correctly enumerates the values returned, which is the main completeness requirement here. Combined with the data-handling caveats, it is adequate for a low-complexity, one-parameter tool; only the semantics of count and failure on non-numeric columns remain unspecified.

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

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

Schema description coverage is 0% and the single `column` parameter has no schema description, so the description must compensate. It does add meaning by constraining the column to a numeric one in the Issafu dataset, but gives no syntax, casing, or naming-convention details for identifying a column.

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 computation (count, min, max, mean, median, sum) over a specific resource (a numeric column of the Issafu dataset). It distinguishes itself from neighbors like dataset_compare and dataset_top by being the single-column statistics tool. It does not explicitly name or contrast any sibling, so it falls short of a 5.

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

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

There is no when-to-use or when-not-to-use guidance, and no alternatives are named, even though siblings such as dataset_top and dataset_compare can serve overlapping analytical needs. The usage is only inferable from the purpose statement, not stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says nothing about how many rows come back by default, the 50-row cap, tie-breaking, error behavior for non-numeric columns, or whether this is a read-only operation — all of which an agent would need.

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 tightly-packed sentence with the core action front-loaded and a helpful intent gloss. The em-dash construction and nested quotes make it slightly less scannable than it could be, but there is no wasted text.

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 3-parameter, no-output-schema, no-annotation tool, the description covers the essential 'what' but omits ordering defaults, result volume, and failure modes. An agent can call it, but with meaningful guesswork remaining.

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

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

Schema description coverage is only 33% (only 'ascending' is documented in the schema), so the description must compensate. It adds real meaning by requiring the column to be numeric and implying directionality, but it never mentions the 'limit' parameter or its bounds, leaving that semantics solely to the schema's constraints.

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 clear action (return the highest/lowest rows) on a specific resource (the Issafu dataset rows) constrained by a numeric column. It distinguishes itself from dataset_stats and dataset_search by framing the operation as a ranking/top-N query, though it never explicitly names those siblings.

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

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

The quoted intent phrase 'which is the most/least X' implicitly tells the agent when this tool applies, and the parenthetical '(or lowest)' hints at the ascending case. However, no alternatives are named and no conditions for choosing dataset_top over dataset_stats or dataset_search 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?

No annotations are provided, so the description carries the full behavioral burden. It adds useful domain context (nothing is bought/paid, no quote guaranteed, it is free) but that describes the subject matter rather than this tool's own execution behavior — it never states that the tool is a safe, side-effect-free read. Reasonable but incomplete without annotations.

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

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

Two compact sentences with the imperative 'Read first.' front-loaded, followed by the substance and return content. No filler, though the phrasing describing the tool's output indirectly ('States plainly what submit_enquiry does') costs a little 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?

With no output schema, the description must convey the return content, and it does: recipients of the details, consent wording, and the confirmation step. Combined with zero parameters and no annotations, this is close to sufficient, though it could state the form of the returned documentation more precisely.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. No parameter semantics are needed or missing.

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 makes clear this is a documentation/describe tool that returns an explanation of the enquiry flow ('States plainly what submit_enquiry does... Also returns who receives the details, the consent wording, and how the person confirms'). The verb is implicit rather than explicit, but the resource and returned content are identifiable and it is distinguishable from data tools like enquiry_fields or dataset_* siblings.

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

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

'Read first.' gives an explicit ordering cue for when to consult this tool before acting. However, it names no alternative (e.g. enquiry_fields, submit_enquiry) and gives no when-not condition, so routing guidance is implied rather than spelled out.

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

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

With no annotations, the description carries the disclosure burden, and it does so by enumerating exactly what is returned (key, label, type, requiredness, help text, allowed options) — effectively substituting for the missing output schema. It adds no auth, rate-limit, or error-case context, but for a zero-parameter read tool the important behavior is covered.

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

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

Two sentences, zero waste, and the payload contents are front-loaded before the follow-up action. The final clause about keying answers by field key is the single most actionable detail and is placed last where it lands.

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 parameterless read tool with no output schema, the description supplies enough: it lists every returned attribute and connects the result to submit_enquiry. Only the ambiguity with the sibling enquiry_describe keeps it from being fully self-sufficient.

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

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

The tool takes no parameters, so there is nothing to document and the baseline is 4. The description correctly spends its words on the output shape instead of inventing input detail.

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

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

Names the resource precisely (the Issafu enquiry form fields) and enumerates what each field carries: key, label, type, required flag, help text, and allowed options. An agent can tell this is a schema-introspection tool. It does not, however, distinguish itself from the sibling enquiry_describe, leaving mild ambiguity about which to call.

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 second sentence gives real downstream context: 'Pass answers to submit_enquiry keyed by field key,' which implies this is the prerequisite step before submitting. There is no explicit when-to-use statement and no routing against the sibling enquiry_describe, so usage is implied rather than stated.

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

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

With no annotations, the description carries the full burden and does well: it discloses the auth scheme, that export pages are metered per key per day (a rate/quota constraint), page granularity, and that the unauthenticated response explains how to obtain a key. It does not say whether the export is a snapshot or live, nor what the page envelope contains.

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 tight telegraphic sentences, front-loaded with scope and pagination before the auth/quota conditions. No filler, though the fragment style is a bit clipped and the no-key sentence could be folded in.

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

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

With no output schema and no annotations, the description still covers the essentials an agent needs to call it: scope, paging size, auth, metering, and the unauthenticated response. Missing details (page indexing, whether a total count is returned) are minor for a two-parameter export.

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

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

Schema description coverage is 0% and neither parameter is documented in the schema, so the description must compensate. 'Pages' implies the page parameter and '200 a page' explains the pageSize ceiling, but neither parameter is named or explained directly, leaving the compensation partial.

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 ('Every entity of Issafu register, 200 a page, with provenance'), which cleanly separates it from the filtering siblings (entities_search, entity_lookup). It never names an alternative explicitly, so an agent must infer that this is the bulk dump rather than the query tool.

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

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

Prerequisites are covered: an access key via Authorization: Bearer is required, and the no-key behavior is described. However, there is no guidance on when to choose this over entities_search / entities_in for narrower queries, which is the main routing decision an agent faces among these 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 are absent, so the description carries the full behavioral burden. It discloses pagination ('50 a page'), which is genuine beyond-schema context, but says nothing about auth requirements, how to advance pages, whether results are capped, or what an entity record contains.

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 dense sentence with the scope front-loaded and no filler. Slightly awkward phrasing ('The Issafu register entities in one region') but nothing wasted.

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

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

For a 4-parameter, no-output-schema, no-annotation list tool, the description covers scope and paging but omits how to page through results and what comes back. Adequate but leaving real gaps for an agent that must iterate pages.

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

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

Schema coverage is 0%, so the description must compensate. It helpfully clarifies that region accepts 'id or name' (the schema only says string), that service is an optional narrowing filter, and that page size is 50 — but the 'page' parameter is never defined and its interaction with pageSize is 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?

The description names a specific verb+resource: listing the register's entities scoped to a single region, with an optional service filter. It is clearly distinct from entity_lookup (single) and entities_search (query-driven), though it never names those siblings explicitly, so the differentiation is inferred 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?

There is no when-to-use guidance and no alternative named. An agent must infer from 'in one region' that this is the bulk-by-region listing as opposed to entities_search or entities_export, with no stated condition selecting one over the other.

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

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

With no annotations, the description carries the full disclosure burden, and it does convey the substance of what is returned (shape, counts, provenance fields). However, it says nothing about whether the payload is cached, how large it is, or that it is a non-mutating introspection call, and there is no output schema to fill that gap.

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?

One compact sentence plus a three-word directive; nothing is padded. The content list is dense and comma-chained, and the critical "Call this first" instruction sits at the end rather than being front-loaded, which is the only structural weakness.

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, no-output-schema introspection tool, the description adequately explains the return content so the agent knows what it will learn. Without annotations or an output schema, a little more on payload form (e.g., that it is a metadata document rather than rows) would close the remaining 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?

The tool takes zero parameters and the description introduces none, so there is no parameter semantics to document. Baseline 4 applies for a parameterless call.

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

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

The description names a clear resource (the Issafu register) and enumerates exactly what it reports: fields, entity counts, regions and services, identifier schemes, and citation info. The verb is implicit (a descriptive/introspective read rather than an action), and the duplicated "register register" hurts polish, but an agent can still tell what comes back without opening anything else.

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?

"Call this first" gives explicit sequencing guidance that no sibling provides, which is genuinely useful for orienting an agent in a 30-tool surface. It stops short of naming alternatives or stating when-not to use it, so it misses the top band.

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

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

With no annotations, the description carries the full burden. It discloses the match fields and the 50-row cap, which is genuinely useful behavior. But it is silent on auth requirements, ordering, whether the cap truncates silently, and the result shape, which for a zero-annotation tool is a real gap.

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 front-loaded sentence covering match fields first, then optional filters, then the row cap. No filler, nothing repeated.

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 search with no sibling routing, no annotations, and no output schema, the description supplies the query semantics, filter semantics, and result cap. It could go further by describing the returned fields or default limit, but an agent can call it correctly as written.

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

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

Schema coverage is 0%, and the description compensates well: it explains that `q` matches name/commercial name/website/address/authority, that region accepts an id or a name, and that service accepts a slug or a name. Those id-vs-name and slug-vs-name details are meaningfully beyond the bare string types in the schema. The only gap is documenting `limit` behavior explicitly.

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

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

The description names a specific verb (search) and resource (entities of the Issafu register) and enumerates the searched fields, so an agent knows exactly what this returns. It does not, however, distinguish itself from siblings like entity_lookup, entities_in, or dataset_search.

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

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

Usage is implied: use it when you have a text query and optional region/service filters. There is no explicit when-to-use versus when to prefer entity_lookup (exact match) or entities_in, and no stated 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?

With no annotations, the description carries the behavioral burden. It discloses the matching mode ('Exact match') and the return payload ('returns the whole record with its page'), which is genuinely useful. It says nothing about permissions, authentication, rate limits, or failure behavior when no entity matches, leaving meaningful gaps for a bare lookup tool.

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

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

Two short sentences, front-loaded with the resource and the key inputs, then the matching and return semantics. 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?

For a read-only single-record lookup with no output schema and no annotations, the description covers the inputs, the exact-match behavior, and what is returned (full record plus page). What remains under-specified is error/empty-result behavior and whether slug and scheme/value are alternatives or can combine, but the essentials for correct invocation are present.

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

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

Schema coverage is only 33% (only 'scheme' is documented), so the description must compensate, and it does: it explains that 'scheme' and 'value' form a pair (scheme + value, e.g. lei) and that 'slug' is the page slug. That clarifies the two mutually exclusive lookup paths beyond the raw schema, though it does not spell out the expected identifier formats for other schemes.

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

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

The description names a specific verb (retrieve) and resource (Issafu register entry for a firm) and states the two lookup keys (register identifier scheme+value, or page slug). It is clear enough to distinguish a single-record fetch from the many search/list siblings such as entities_search or entities_in, though it never explicitly contrasts itself with them.

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

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

Usage is only implied: 'Exact match' signals this is for when you already have a precise identifier or slug rather than a fuzzy query, which helps against entities_search. There is no explicit when-to-use/when-not-to-use statement and no mention of what to do if the identifier is unknown.

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

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

With no annotations, the description carries the full burden and does add real behavioral context: verification happens server-side, a short or wrong-token transfer is reported by name and not credited, and success transitions the listing to review. It still omits failure/error semantics, idempotency, auth requirements, and where the 'reference' originates, leaving meaningful gaps for a state-changing call.

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

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

Two sentences with no filler; the server-side mechanics are front-loaded and the outcome sentence is short. The first sentence is dense with clauses but every clause carries information.

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

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

For a 2-parameter state-changing tool with no annotations and no output schema, the description should ideally cover prerequisites and the call outcome/return. It explains the success and short-transfer cases but leaves the caller without guidance on preconditions, error responses, or how to obtain the required reference.

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 50%: session is documented in the schema, while id is undocumented there. The description partially compensates by implying the id is the transfer 'reference' used to locate the payment, but it does not define format or origin of that reference, so the coverage gap is only half closed.

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 activity — the server finding a USDC transfer by reference, reading the treasury balance change, and moving the listing into review — so an agent understands this is the settlement/confirmation step of a USDC payment. It is clear but never names the sibling (e.g. listing_pay_usdc) it follows, so differentiation relies on the reader inferring the payment lifecycle.

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 guidance, no stated prerequisite (that a USDC payment must first be initiated and a reference obtained), and no alternative named. The agent must infer that this is called after listing_pay_usdc, which is not stated anywhere in the text.

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

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

With no annotations, the description carries the full behavioral burden, and for a zero-parameter information tool that burden is light: it never states that the call is read-only, parameter-free, or returns static reference text rather than data. 'Read this to the person first' does add a behavioral instruction about delivery, which is more than a bare content list, but the safety/idempotency profile an agent would want is still unstated.

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

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

Two sentences: the content inventory comes first, the operational instruction second, with no filler. The list-style first sentence is slightly dense but each listed item is load-bearing, and the closing directive is front-loaded enough to steer behavior.

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 no-parameter, no-output-schema reference tool, the description is largely sufficient: it says what the content covers and when to surface it. The only real gap is the lack of boundary-setting against listing_terms, which an agent could otherwise conflate with 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?

The tool takes zero parameters, so the baseline is 4. The description's mention of 'every profile field it takes' actually pre-answers the reader's natural question about what fields a listing requires, adding value beyond the empty 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 enumerates exactly what the resource covers: what a listing is, cost, payment method, publisher, and the profile fields it accepts. That is a specific, scannable scope statement rather than a restatement of the name. It does not, however, differentiate itself from the overlapping sibling listing_terms, which plausibly covers pricing/terms content as well.

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 final sentence gives a genuine usage directive — 'Read this to the person first' — which tells the agent when in a flow to invoke it. But it names no alternatives (listing_terms, enquiry_describe) and gives no condition for choosing this over them, so the routing guidance is implied at best.

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

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

With no annotations, the description carries the full burden. It usefully discloses validation behavior ('scam-shaped or off-list field is refused by name'), that no money changes hands yet, and what is returned (id + awaiting_payment). It omits auth/session requirements, the consequences of missing terms acceptance, and idempotency or error handling.

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 tight sentences with no filler, and the primary action is front-loaded. Slightly informational but each sentence contributes (behavior, field guidance, return value).

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

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

For a mutation tool with no annotations, no output schema and sparse schema coverage, the description covers return values and one validation rule but leaves too much unsaid about authorization (session), the terms gate, and required-field expectations. It is adequate but not complete enough for a 13-parameter tool.

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

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

Schema description coverage is only 15%, with 13 parameters (7 required) including nested objects. The description does not explain any parameter semantics itself and instead redirects to listing_describe, which is a reasonable pattern but leaves required fields like termsVersion, termsAccepted, authorised and services unexplained within this definition.

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: 'Creates a listing draft on Issafu.' The word 'draft' plus the awaiting_payment status distinguishes it from the confirm/pay siblings, though it does not explicitly name them. An agent can infer this is the pre-payment creation step.

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?

'Send the fullest profile you can (listing_describe lists the fields)' is a useful instruction and points to a sibling for field discovery. However, it gives no guidance on when to call this versus listing_confirm_usdc or the pay tools, and no prerequisites or ordering constraints are stated.

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

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

With no annotations, the description carries full behavioral burden. It does disclose the useful trust model — payment is learned from Stripe's verified event, never from the browser — which tells the agent not to treat browser return as confirmation. But it omits URL expiry/reuse, whether the call is idempotent, and what the agent should do next (e.g., poll listing_status).

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

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

Two dense sentences with zero filler; the return value is front-loaded and the trust-model caveat follows immediately. Every clause earns 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?

No output schema or annotations exist, so the description must be self-sufficient. It covers the return shape and confirmation semantics well, but leaves the id parameter and post-payment agent workflow unexplained for a payment-flow 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 only 50%: session is documented as coming from agent_session_verify, but id is a bare string with no description. The description never says what id refers to (presumably a listing identifier) — "at the site's price" only vaguely implies it, so it fails to compensate for the coverage gap.

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

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

Concrete verb and resource: returns a Stripe Checkout URL for a listing payment, and the title disambiguates it as a human-completed hosted checkout. However, it never distinguishes itself from the similarly named sibling listing_pay_stripe, which an agent could easily confuse with this tool.

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

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

"A human completes it in a browser" implies the condition under which this tool applies (human-in-the-loop card payment) versus programmatic payment siblings. But no alternative is named and there is no explicit when-not-to-use guidance, so the agent must infer the routing.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses that the server determines the amount (never the caller's named amount), charges off-session, and returns either 'succeeded' (listing enters review) or 'requires_action'. It omits auth prerequisites, idempotency, and failure handling, keeping it short of a 5.

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

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

A single dense sentence front-loads the action and the charging behavior with no filler. It is slightly crammed with multiple clauses (entitlement, off-session charge, two outcomes, fallback tool), but every clause earns 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 a payment mutation tool with no annotations and no output schema, the description supplies the outcomes an agent needs. The remaining gap is the unexplained 'id' parameter and absent failure/auth behavior, but the core call contract is complete.

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

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

Schema coverage is only 33%: the 'session' param is documented in the schema, but 'id' and 'paymentMethod' are not. The description compensates for 'paymentMethod' (explaining it is a pm_... id the agent is entitled to use) but leaves 'id' entirely unexplained, so the coverage gap is only partially bridged.

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 (send a Stripe payment method id) and effect (the server charges the SITE's price off-session), naming the resource unambiguously. It explicitly distinguishes itself from sibling listing_pay_card by routing 'requires_action' outcomes there, so an agent can separate 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 clear context for use (a Stripe payment method the agent is entitled to use) and names listing_pay_card as the fallback when a human is needed. It stops short of contrastive guidance against listing_pay_usdc or listing_confirm_usdc, so the alternative selection 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?

With no annotations, the description carries the full burden. It usefully discloses that the response is a transfer request to be signed externally and that a confirmation step follows, but says nothing about request expiry, idempotency, whether the listing is reserved, or what happens if the transfer is not confirmed.

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

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

Two tight sentences, front-loaded with what the call returns and followed by the required next action. No filler, though the parenthetical about the read-only key is dense and could be split for 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?

With no output schema, the description compensates well by enumerating the returned fields and the mandatory follow-up call. Still, it omits the meaning of the id parameter and any failure/expiry semantics an agent would want before paying.

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

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

Schema coverage is only 50% and the description adds no meaning for either parameter — neither the id nor the session token is explained in the description (only the schema notes session comes from agent_session_verify). It does explain the returned reference field, but not the 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?

Specific verb and resource: it 'Returns the Solana Pay transfer request' and enumerates the payload (recipient, amount, USDC mint, unique reference). The USDC/Solana framing plus the named follow-up tool listing_confirm_usdc cleanly separates it from the listing_pay_card and listing_pay_stripe siblings.

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

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

It gives clear procedural context: pay the request from the wallet with the reference as a read-only key, then call listing_confirm_usdc. That tells the agent exactly where this fits in the flow, though it never explicitly contrasts with the card/stripe payment siblings for choosing a rail.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that only published rows are returned and that results can be scoped to one register entry, but it omits whether the operation is read-only, what permissions are needed, pagination behavior, or return shape. This is too thin for a read tool with zero annotation coverage.

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 definition is a single compact sentence with no filler, and the published-rows constraint is placed prominently. It is appropriately sized for a simple lookup tool, though the phrasing is slightly cryptic and could be clearer about the operation.

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

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

For a tool with no annotations, no output schema, and fully undocumented parameters, the description is not complete enough for reliable invocation. It conveys the broad concept but leaves key operational and parameter details to inference. An agent would need external context to call it correctly.

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

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

The schema has two parameters, 'value' and 'scheme', both with 0% description coverage. The description's phrase 'optionally for one register entry' vaguely suggests a filter but does not explain what 'value' or 'scheme' mean or how they combine to identify a register entry. It compensates only minimally for the missing schema documentation.

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 ('firms added on top of the register'), the scope ('published rows only'), and an optional filter ('for one register entry'). However, it never uses a clear operation verb such as list or get, and it does not differentiate itself from sibling listing_* tools. The purpose is inferable but not sharply 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?

It mentions an optional filter but gives no guidance on when to use this tool versus alternatives like listing_describe or dataset_search. No prerequisites, exclusions, or use contexts are provided. The optional filtering hint is the only usage clue.

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

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

No annotations are provided, so the description carries the full burden. It does add real behavioral value by enumerating the possible status values, which the schema does not expose as an enum. However, it says nothing about permissions/auth beyond the session token, ordering, pagination, or whether access is read-only, which an agent would want to know.

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?

One sentence, front-loaded with the scope and immediately followed by the returned status vocabulary. Zero padding and nothing that fails to earn its place.

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

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

With no output schema, the description does the work of saying what comes back (all listings plus status) and enumerating the status values, which is the key missing structure. It omits ordering and pagination behavior for what could be a long list of listings, a minor remaining 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?

There is a single 'session' parameter, and schema_description_coverage is 100%, so the schema already explains where the token comes from and its length bounds. The description adds no parameter-level detail, which matches the baseline for full schema coverage.

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

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

States a clear resource and scope: 'Every listing of this account' plus the status field it returns. The verb is implicit ('list'), but the intent is unambiguous. It doesn't explicitly name the sibling it differs from (e.g. listings_published, which returns only a subset), so it stops short of full sibling differentiation.

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

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

Usage is implied by the word 'Every' – a broad personal-listing view – which naturally contrasts with listings_published, but that contrast is left for the agent to infer. There is no explicit when-to-use, when-not-to-use, or named alternative.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one useful contract detail (the returned version must be echoed back as termsVersion), but says nothing about whether this is a read-only call, what the return shape or size is, or any auth/rate constraints.

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 tight sentence with no filler, and the round-trip hint is embedded rather than buried. It is slightly cryptic as an unverbed fragment, which keeps it out of the top band.

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

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

With no output schema and no annotations, the description should explain what actually comes back (clause list, version identifier, profile field inventory) and how to use it. Instead it gestures at the contents in one ambiguous clause, leaving the agent to guess at the return structure and the intended call sequence.

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 takes zero parameters and the schema is empty, so there is nothing for the description to clarify. Baseline for a no-argument tool.

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 (listing terms/clauses plus profile fields) but is a noun phrase with no verb, so the agent must infer it is a retrieval tool. It is roughly distinguishable from siblings like listing_describe or listing_draft, but the phrasing 'the clauses a listing is judged by' is indirect enough that an agent could confuse it with a schema/validation endpoint.

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 parenthetical 'send it back as termsVersion' hints at a workflow, but there is no explicit when-to-use statement, no prerequisites, and no named alternative among the many sibling tools. The agent has to reconstruct the calling context itself.

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

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

With no annotations, the description carries the full behavioral burden, yet it only says the listing is "taken down." It doesn't disclose whether the action is reversible, what happens to the listing's data or state afterward, whether confirmation or specific permissions are required, or what the response contains — all material for a destructive mutation.

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 short, front-loaded sentence with no filler or repetition. It is efficient, though its brevity edges toward under-specification rather than true conciseness.

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

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

For a destructive mutation with zero annotations, no output schema, and an undocumented required parameter, the description is far too thin. An agent cannot determine side effects, recoverability, or success/failure signalling from what is provided.

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 50%: the session token is documented in the schema, but the required `id` parameter (length 10-60) has no description anywhere, and the description adds no clarification such as whose listing id is expected. With no enum or format hints, the agent gets no help identifying the id's origin or constraints.

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 ("takes down") on a specific resource ("listing of this account"), which clearly separates it from read/creation siblings like listing_draft, listing_status, and listings_published. It stops short of naming what makes withdrawal distinct (e.g., irreversible removal vs. unpublishing), so it lacks explicit sibling differentiation.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the related tools (listing_confirm_usdc, listing_status, listings_published) an agent might weigh instead. The agent must infer that withdrawal is the terminal step in the listing lifecycle.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses very little. "Labelled as sponsored in the answer" is a useful output-transparency cue (the response flags sponsored content), but nothing is said about read-only vs mutating nature, permissions, caching/freshness, or what 'active' 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?

A single, front-loaded sentence with no padding. The parenthetical enum inline is compact, though the phrasing ("The Sponsored slot's contents") is slightly oblique as an opener.

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

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

With no annotations, no output schema, and three parameters at 0% schema coverage, the description should explain return shape, what makes a placement 'active', and how region/leaf interact with page. None of that is present, so an agent cannot call it confidently beyond the simplest home case.

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

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

Schema description coverage is 0%, so the description must compensate. It restates the `page` enum values (already in the schema) and implies region/leaf are used with those page types, but never explains what `region` or `leaf` should contain or their length limits, leaving the remaining parameters undocumented in both places.

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

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

Names the resource (the Sponsored slot's contents for a page) and its scope (home | region | leaf), so an agent knows it fetches sponsored placements rather than doing anything else. The verb is only implied ("contents"), but the resource and scope are specific enough to distinguish it from any sibling.

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 statement of when to reach for this tool versus alternatives, nor any prerequisite (auth, sponsor-account requirement, freshness). The parenthetical enum hints at input shape but not at invocation context.

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

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

With no annotations, the description carries the full burden and discloses the two-step flow, validation summary, consent requirement, confirmation token, and post-submission email verification before providers see the enquiry. It does not cover failure modes, session prerequisites, or what happens if consent is false, leaving minor gaps for a multi-step submission tool.

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

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

The description is front-loaded with the purpose and a key distinction, then structured into clear Step 1 and Step 2 instructions. Every sentence contributes necessary information, with no redundancy, despite the inherent complexity of a two-step process.

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

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

Given the absence of an output schema and the multi-step behavior, the description is nearly complete: it explains the validation response, consent line, token, and email confirmation. It could mention session prerequisites or error handling, but for the core behavior it is sufficient.

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

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

Schema coverage is 100%, so all parameters are documented in the schema. The description adds value beyond the schema by explaining that answers must be keyed by field key from enquiry_fields and by showing how the confirmation token from step 1 is used in step 2, clarifying the intended workflow.

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 ('Submits an enquiry to Issafu') and immediately distinguishes it from alternatives ('NOT a purchase, NOT a guaranteed quote'). It clearly identifies the tool's purpose and differentiates it from purchase/quote siblings without requiring schema inspection.

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

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

It provides explicit step-by-step guidance: Step 1 requires answers and consent=true and returns a summary, consent line, and token; Step 2 is only after the person agrees, with the same answers, consent=true, and the confirmation token. It also references enquiry_fields for the answer keys, and clearly states when not to use it (not a purchase, not a guaranteed quote).

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