Darknet MCP

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the API-key authentication requirement, which is genuine value, but says nothing about rate limits, pagination, or whether the list is cached/updated.

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, zero waste; the purpose leads and the auth prerequisite follows. Nothing redundant or padded.

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-param read-only list tool with full schema coverage and annotations covering safety, the description is close to sufficient and does indicate the returned resource (blacklist of IPs). It lacks any note on result shape/pagination, but with no output schema that gap is minor for this tool's complexity.

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

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

Schema description coverage is 100%, with limit and confidence both documented including defaults and ranges, so the schema does the heavy lifting. The description adds no meaning beyond that, which makes the baseline 3 appropriate.

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

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

States a specific verb (Get) and resource (AbuseIPDB blacklist of most reported malicious IPs), so an agent understands it returns a curated threat list rather than a per-IP lookup. It is distinguishable from siblings like abuseipdb_check and abuseipdb_reports, though it does not name them 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?

The description notes the ABUSEIPDB_API_KEY prerequisite but gives no when-to-use guidance, no conditions selecting it over abuseipdb_check/abuseipdb_reports, and no exclusions. The agent must infer that this is a bulk blacklist pull versus a targeted lookup.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful operational detail, the ABUSEIPDB_API_KEY requirement, but says nothing about rate limits, quota behavior, or what a partial/missing reputation result looks like.

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 short sentences, each earning its place: purpose first, then return fields, then the auth prerequisite. Nothing is repeated or padded.

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 three-parameter read-only lookup with full schema coverage and no output schema, the description covers what it does, what comes back, and the credential requirement. An agent has everything needed to call it correctly.

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

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

Schema description coverage is 100%, so ip, max_age, and verbose are already documented in the schema. The description adds no parameter-level semantics (e.g., what max_age does to the confidence score) beyond the baseline, which is the expected 3 when the schema does the heavy lifting.

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 ('Check an IP address against AbuseIPDB for abuse reports') and lists the returned fields, so the purpose is unambiguous. It does not distinguish itself from close siblings like abuseipdb_reports, abuseipdb_blacklist, or abuseipdb_check_block, which an agent must otherwise infer.

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 tool versus the other AbuseIPDB siblings or greyoise_ip/otx_ip style alternatives. The only contextual cue is 'Check an IP address', which is implied usage rather than explicit routing guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description usefully adds that an ABUSEIPDB_API_KEY is required, but says nothing about rate limits, quota consumption, or how a whole block is aggregated, which would matter for a bulk external lookup.

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-loading the core action and following with the auth prerequisite. Every sentence earns its place with no filler.

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

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

For a simple two-parameter read-only lookup with no output schema, the description covers what the tool does and its auth requirement adequately. It could be slightly fuller on the block-level semantics, but nothing essential to invocation is missing.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema (CIDR block example and max_age default/min/max). The description adds no format or syntax detail beyond that baseline.

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 (check), resource (entire CIDR network block), and data source (AbuseIPDB). The 'entire block' scope implicitly distinguishes it from the single-IP sibling abuseipdb_check, but does not name that 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?

The phrase 'entire CIDR network block' implies when to use this over a single-IP check, but there is no explicit when-to-use, exclusion, or named alternative despite three abuseipdb* siblings existing. Usage is only implied.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the auth requirement (ABUSEIPDB_API_KEY) and notes the return contents (comments and categories), which is useful context beyond the annotations, but it omits pagination/limit behavior.

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

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

Three short sentences, front-loaded with the purpose, then return contents, then the auth requirement. No filler and every sentence 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?

With no output schema, the description partially compensates by naming what is returned (report comments and categories) and the API key requirement. The safety profile is carried by annotations, so the remaining gap is minor (pagination/limit semantics), making this adequately complete for a read-only lookup.

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

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

Schema description coverage is 100%, so the schema fully documents ip, limit, and max_age with defaults and bounds. The description adds no parameter-level detail beyond what the schema provides, 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 gives a specific verb and resource ('Get individual abuse reports for an IP from AbuseIPDB'), which is clearly distinct from the sibling abuseipdb_check (the reputation/check endpoint) and abuseipdb_blacklist. It does not explicitly name those siblings to differentiate, but the scope 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?

There is no guidance on when to use this versus the sibling abuseipdb_check or abuseipdb_blacklist, nor any stated prerequisites beyond the API key. The agent must infer the use case from the description alone.

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

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

Annotations already declare readOnly, openWorld and non-destructive behavior, so the safety profile is covered. The description adds a genuinely useful fact the annotations do not carry: the ABUSECH_AUTH_KEY prerequisite, plus the accepted hash algorithms. It stops short of noting rate limits or whether a miss returns an error or a null result.

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

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

Three tight sentences with zero filler, and the purpose is front-loaded ahead of the input format and auth note.

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 read lookup with full schema coverage and no output schema, purpose, accepted input, and auth are all covered. Minor omission: no indication of what the lookup returns or how a not-found hash is surfaced.

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

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

Schema coverage is 100% and the schema already enumerates MD5/SHA1/SHA256 for the single hash parameter. The description restates that same set without adding format, casing, or length constraints, so the baseline of 3 is correct.

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 ('look up') plus resource ('malware sample in MalwareBazaar') plus scope ('by hash'). An agent can distinguish this from the bazaarRecent and bazaarTag siblings without opening any schema.

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

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

The lookup key is clear (you must have a hash), which implies when this tool applies. But it never names bazaarRecent or bazaarTag as the alternatives for hashless browsing, so selection between the three bazaar tools is left to inference.

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

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

Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false, so the safety profile is covered structurally. The description adds the useful requirement of ABUSECH_AUTH_KEY, but says nothing about rate limits, pagination, or how many samples are returned.

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 short sentences, front-loaded with purpose. The middle sentence ('Returns the most recently submitted samples') partially restates the opening, a minor redundancy, but overall it reads efficiently.

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 read-only tool with annotations covering safety and no output schema, the description covers purpose and auth. However, the selector's valid options and the return size remain unexplained, which matters given the vague schema description.

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?

Only one parameter (selector) with 100% schema description coverage, so the schema baseline applies. The description adds nothing about the selector's valid values beyond the schema's 'default: time', leaving its meaning ambiguous.

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 ('Get') and resource ('recent malware samples from MalwareBazaar'), with the 'recent' scope distinguishing it from the bazaarHash and bazaarTag siblings. It stops short of explicitly naming those siblings, so it's clear but not fully differentiated in text.

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

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

The description says what the tool returns but never states when to use it versus bazaarHash or bazaarTag, nor any exclusions or prerequisites beyond the auth key. Usage is only implied by the 'recent' framing.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds two useful facts beyond the annotations: the required ABUSECH_AUTH_KEY credential and the mutually exclusive input constraint. It does not mention rate limits or result paging, keeping it short of a 5.

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

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

Two tight sentences, front-loaded with the resource and source, followed by the invocation constraint and credential requirement. 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 two-parameter, no-output-schema search tool, the description covers purpose, exclusivity, and auth. The remaining gap is routing against sibling bazaar tools, a minor omission given the simplicity of the operation.

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

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

Schema coverage is 100% and both parameter descriptions already state 'provide exactly one of tag or signature'. The description repeats that constraint rather than adding new meaning such as matching behavior or case sensitivity, 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?

Specific verb+resource: search MalwareBazaar (abuse.ch) by tag or malware family signature. The source is named, which separates it from sibling sources like threatfoxTag, urlhausTag, and bazaarHash. It does not explicitly contrast itself with the closest siblings (bazaarHash, bazaarRecent), so it stops short of a 5.

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

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

The exactly-one-of constraint tells the agent how to invoke it, but there is no guidance on when to pick this over bazaarHash or bazaarRecent, or whether tag vs signature is preferred for a given intent. 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds a genuinely new behavioral fact not in the annotations: no API key is required and the endpoint is free, which affects auth handling. It does not describe response shape, but for a no-param list endpoint that gap is minor.

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, zero waste, with the what (list data classes) front-loaded and the access note second. Appropriately sized for a trivial lookup endpoint.

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, read-only enumeration endpoint with annotations covering safety and no output schema, the description covers purpose and access requirements. Adding a hint that these classes are the valid values used to filter breach searches would make it fully self-sufficient, but nothing essential is 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?

The tool takes zero parameters, so the baseline is 4 and there is no parameter surface for the description to clarify. Nothing is missing or contradicting on this dimension.

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 ('List all data classes') and immediately defines the resource for an agent that may not know the term ('types of compromised data known to HaveIBeenPwned'). This is clearly distinguishable from sibling breach tools like breachList and breachSearch, which return breach records rather than the class taxonomy.

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

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

The description gives a useful access hint ('Free endpoint, no API key required') but never states when to reach for this tool versus breachList, breachSearch, or breachPastes. Usage is only implied — an agent must infer that this supplies the vocabulary for filtering other breach queries.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds a genuinely useful operational fact — free endpoint, no API key required — but says nothing about response shape, lookup failures, or case sensitivity beyond the schema hint.

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

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

Two short sentences, zero filler, with the core action front-loaded and the auth caveat trailing as secondary information. 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?

For a single-parameter read with no output schema, the description could reasonably hint at what 'details' are returned (breach date, affected accounts, data classes). It omits return-value context, though annotations cover the safety dimension and the schema covers the input fully.

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

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

Schema description coverage is 100% and the schema already gives the Pascal-case format and examples ('Adobe', 'LinkedIn'). The description adds no syntax or naming detail beyond what the schema provides, so the baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('details of a specific data breach by name') plus the source (HaveIBeenPwned), which distinguishes it from breachSearch/breachList by implying exact-name lookup rather than querying. It does not name a sibling explicitly, so it stops short of a 5.

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

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

The phrase 'by name' implies the tool is for when you already know the breach identifier, which is useful routing context against breachSearch. However, there is no explicit when-to-use, when-not-to-use, or named alternative, leaving the agent to infer the distinction.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds a genuinely useful behavioral fact beyond the annotations – that the endpoint is free and requires no API key – which directly answers an agent's auth/setup question.

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 action and its scope front-loaded and the auth/cost caveat following immediately. No filler, no redundancy with the title or schema.

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

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

For a parameterless, read-only tool the description covers the essential decision inputs: what it returns conceptually and that no key is needed. There is no output schema, so a sentence sketching the returned breach fields would have been a nice addition, but nothing critical to correct invocation is missing.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. The description neither needs nor provides per-parameter detail, and nothing about invocation is ambiguous.

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

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

States a specific verb and resource ('Get the most recently added data breach') and names the data source (HaveIBeenPwned), which is enough to distinguish it from siblings like breachList or breachSearch. However, it does not explicitly contrast itself with the closely related breachGet/breachList tools, so it falls 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?

The word 'Latest' plus 'Free endpoint, no API key required' implies the scenario in which this tool is attractive (a quick, zero-config peek at the newest breach). But there is no explicit when-to-use guidance and no mention of the alternative tools (breachList, breachSearch, breachGet) that cover historical or targeted queries.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely new operational context beyond the structured data: the endpoint is free and requires no API key, which affects how an agent should call it. It omits return volume/paging behavior, keeping it from 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?

Three short sentences, no filler, with the core action front-loaded and the auth detail trailing as supporting context. Every sentence carries distinct 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 zero-required-param read-only list tool with a fully documented schema and no output schema, the description covers what it does, the optional filter, and the auth model. The only gap is any note on result size or ordering, which is minor here.

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

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

With 100% schema description coverage, the schema already documents the single 'domain' parameter and even gives an example ('adobe.com'). The description only restates that filtering by domain is optional, adding no syntax or format detail beyond the schema, 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 gives a specific verb (list) plus resource (data breaches) and names the source (HaveIBeenPwned), which is enough for an agent to know what it returns. It does not explicitly distinguish itself from close siblings like breachLatest, breachGet, or breachSearch, though 'all known' implicitly contrasts with a 'latest' variant.

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: 'Optionally filter by domain' hints at a browsing/listing use case, but nothing states when to prefer this over breachGet (single breach details) or breachSearch (account lookup). No when-not guidance is offered.

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

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

Annotations already declare this a read-only, non-destructive, open-world call, so the description is not carrying the safety burden. It still adds real behavioral value by disclosing the k-anonymity mechanism and that only the first 5 SHA-1 characters leave the machine — a privacy trait an agent needs for a password tool. It omits rate-limit behavior (Pwned Passwords throttles), which keeps it from a 5.

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

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

Two tight sentences with the core purpose front-loaded and supporting facts (k-anonymity, hash prefix, no API key) following in priority order. No filler or repetition of the tool name.

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 should carry the return-value burden, yet it never says what comes back — a breach count, a boolean, or a list — which is the agent's main reason for calling it. The safety and cost picture is otherwise adequate for a single-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?

One parameter with 100% schema description coverage, so the schema already documents 'The password to check'. The description adds no further parameter semantics such as whether plaintext is accepted or how the hash is derived locally, making this a baseline 3.

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 (check) and an unmistakable resource (a password's appearance in known data breaches), which separates it in kind from sibling breach tools like breachSearch and breachPastes that operate on emails/domains/keywords. It never explicitly names or contrasts those siblings, so it falls short of the 5 calibration where the alternative is called out by name.

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

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

The description makes the intended use obvious from the purpose (checking a password) but gives no explicit when-to-use/when-not guidance and never routes the agent away from breachSearch, breachPastes, or the other breach* siblings. 'Free, no API key required' is useful precondition context but is not selection guidance.

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

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

Annotations already declare readOnlyHint/openWorldHint/destructiveHint=false, so safety is covered. The description adds meaningful behavioral context beyond that: the operation is gated behind a paid HIBP API key, which is genuine operational information an agent needs.

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, purpose front-loaded, with the prerequisite requirement following immediately. Every phrase 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 one-parameter read lookup with annotations covering safety and an existing output-format expectation, the description covers purpose and the auth/cost gate. The main omission is any cross-reference to the closely related breachSearch/breachPassword siblings.

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

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

Schema description coverage is 100% for the single email parameter, so the schema already carries the semantics. The description adds no format, matching, or normalization detail beyond what the schema provides.

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

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

States a specific verb+resource ('Search for an email address in publicly posted pastes') and names the data source (Pastebin, via HaveIBeenPwned). The focus on *pastes* rather than breach dumps implicitly distinguishes it from siblings like breachSearch, though it never names that 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?

Provides a real prerequisite ('Requires HIBP_API_KEY (paid endpoint)'), which is useful context, but gives no when-to-use vs when-not guidance and does not point to breachSearch or breachPassword as alternatives for related lookups.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavioral context beyond annotations: the authentication requirement and that this is a paid endpoint, which affects whether an agent should invoke it.

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

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

Two tight sentences with the core purpose front-loaded ahead of the auth prerequisite. No wasted words, though it is very brief and could have used the space to differentiate from siblings.

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 read-only search tool with a fully documented 3-parameter schema and no output schema, the description covers purpose, resource scope, and auth requirement adequately. Minor gap is the absence of explicit sibling differentiation within the breach tool family.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (account, truncateResponse, includeUnverified) with defaults. The description's '(email or username)' merely restates what the schema already states, adding no syntax or format detail beyond structured fields.

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 ('Search'), resource ('all data breaches'), and scope ('for a specific account (email or username)'), which clearly differentiates it from list-oriented siblings like breachList/breachLatest. However, it does not explicitly name or contrast with the closely related siblings breachPassword and breachPastes, leaving some ambiguity within the breach family.

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 discloses a meaningful prerequisite ('Requires HIBP_API_KEY (paid endpoint)'), which implies the usage context, but gives no explicit when-to-use vs. when-not guidance or named alternatives such as breachPastes or breachPassword. 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real context beyond that: it names the external data source and states the authentication requirement, which the agent must satisfy before calling. It stops short of covering rate limits or empty-result semantics.

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 short sentences, each carrying distinct information: what it does, what it returns, and what it requires. Front-loaded with the purpose and zero 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?

With no output schema, the description helpfully summarizes the return shape (scam reports with categories and descriptions), and annotations carry the safety profile. It is nearly complete for a one-parameter read tool, though it says nothing about behavior when no reports exist or about rate 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?

Schema description coverage is 100% and there is a single required parameter whose meaning ('Bitcoin address to check') is fully documented in the schema. The description adds no format or validation detail beyond that, 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?

States a specific verb (check) and resource (Bitcoin address) plus the data source (ChainAbuse) and what is returned. This clearly differentiates it from the generic btc_address/btc_balance/btc_tx siblings, which cover address data rather than abuse reports.

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

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

The description names the prerequisite (CHAINABUSE_API_KEY) but gives no explicit when-to-use or when-not-to-use guidance relative to btc_address or the other abuse-check siblings (abuseipdb_check, threatfoxSearch). Usage is only implied by the purpose statement.

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

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

Annotations already declare readOnly, non-destructive, open-world behavior, so the safety profile is covered. The description usefully adds what is returned ('balance, transaction count, and recent transactions'), but says nothing about rate limits, API key needs, or result scope beyond that.

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 the action and source, and immediately followed by the return payload. No wasted words.

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

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

With no output schema, the description compensates by enumerating the returned fields (balance, transaction count, recent transactions). For a single-parameter read-only lookup this is nearly complete, with only sibling routing left unaddressed.

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?

Only one parameter exists and schema description coverage is 100%, so the schema fully documents 'address'. The description adds no format or constraint detail beyond the schema, making the baseline 3 appropriate.

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

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

States a specific verb and resource ('Look up a Bitcoin address') plus the data source (blockchain.info), which is clear. However, it does not distinguish itself from siblings btc_balance and btc_tx, whose territory it partially overlaps by returning balance and transactions.

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 and no mention of alternatives. Given that btc_balance and btc_tx are siblings with overlapping output, the absence of routing ('use btc_tx for full history') leaves the agent to guess.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds genuine value beyond that by naming the external data source (blockchain.info) and scoping the result to balance only, not transaction history — relevant for an open-world network 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 short sentences, zero filler, and the core purpose is front-loaded ahead of the disambiguating scope note.

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 specifies the return unit (satoshi), which is exactly the missing context an agent needs. It doesn't mention error behavior for invalid addresses or rate limits from the external provider, leaving a small 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?

Only one parameter, and the schema fully documents it ('Bitcoin address' with length bounds). The description adds no parameter-level guidance beyond the schema, so the baseline of 3 for high schema coverage applies.

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

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

States a specific verb, resource, unit (satoshi) and upstream source (blockchain.info), and implicitly distinguishes itself from transaction-history siblings with 'without full transaction history'. An agent can identify this as a lightweight balance-only lookup without opening the schema.

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

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

'Quick balance check without full transaction history' gives clear usage context and hints at the alternative (transaction-listing tools like btc_tx). It doesn't name a sibling explicitly or state when-not-to-use, so it falls short of the 5 mark.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that by disclosing the return contents (inputs, outputs, fees, block info), which matters because there is no output schema. It stops short of mentioning error behavior for malformed or unknown hashes.

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 zero padding; the purpose is front-loaded and the return summary follows immediately. Nothing could be cut without losing information.

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

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

For a single-parameter read-only lookup with no output schema, the description supplies both the action and the return shape, which is sufficient to call it correctly. Only minor gaps remain, such as behavior on invalid or non-existent hashes.

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

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

Schema description coverage is 100% and the single txhash parameter is fully documented there, including a 64-hex-char pattern. The description's "by hash" adds no format or syntax detail beyond the schema, 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?

States a specific verb and resource ("Get detailed Bitcoin transaction information") and qualifies the lookup key as "by hash," which implicitly separates it from the address-based siblings btc_address and btc_balance. It does not name those siblings explicitly, so differentiation is inferable 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?

Usage is only implied: an agent can infer it should call this when it holds a transaction hash rather than an address. There is no explicit when-to-use, when-not-to-use, or named alternative among the btc_* siblings.

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

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

Annotations already declare readOnly/openWorld/non-destructive, and the description adds substantial beyond that: bounded redacted evidence with provenance and explicit coverage, the single-page fetch semantics of fetch_onion, an explicit negative list (no crawling, new scans, raw documents, malware downloads, invented risk score), and a prompt-injection warning that provider claims are untrusted data. This is unusually rich behavioral disclosure.

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

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

Four front-loaded sentences: purpose first, then what it returns, then the read-only constraints, then the security caveat. No filler, and the ordering lets an agent decide relevance from the first sentence alone.

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, yet the description tells the agent what comes back (bounded redacted evidence, provenance, explicit coverage, shared indicators), what it will not do, and how to opt into onion fetching. For a high-fan-out aggregator with five params this is complete enough to invoke correctly.

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

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

Schema description coverage is 100% and every parameter already carries its own enum/range/bounds documentation, so baseline is 3. The description adds genuine meaning beyond the schema for fetch_onion ('fecthes the supplied page once', default metadata-only, never follows links), nudging it above baseline.

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 (Investigate) plus the full set of accepted resource types (domain, email, IP, hash, URL, v3 onion, Bitcoin address, CVE) and frames itself as spanning 'all eight dark-web and threat-intelligence capability families.' This clearly positions it as the cross-family aggregator versus the many single-purpose siblings like btc_address or onion_lookup.

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

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

The description establishes when this tool applies broadly (one investigation across all capability families) and constrains the risky mode ('explicit fetch_onion opt-in fetches the supplied page once'; 'Only existing-source lookups'). It doesn't explicitly route the agent between this umbrella tool and the granular siblings (e.g. when to prefer pulsedive_indicator over this), so it stops short of full when/when-not guidance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds genuine context beyond the annotations by disclosing what the response contains (per-source configuration status, required API keys, available tools), which matters because no output schema exists.

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

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

A single front-loaded sentence listing the one action and its three-part payload. No filler, no repetition of the name or annotations.

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-only discovery tool with no output schema, the description covers what the call returns and why it exists, which is most of what an agent needs. It stops short of saying when to prefer it over darknet_readiness or how to act on missing API keys.

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 an empty object, so there are no parameter semantics to explain. Baseline 4 applies; nothing in the description contradicts or misrepresents the empty input.

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 (List) and resource (darknet-mcp data sources) and enumerates the payload: configuration status, required API keys, and available tools. An agent can tell this is a discovery/introspection tool, though it never distinguishes itself from sibling darknet_readiness, which likely also reports configuration 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as darknet_investigate or darknet_readiness. The usage is only weakly implied by the word 'List' and the discovery framing.

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

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

Annotations already establish the safe read-only, open-world profile. The description adds genuine behavioral context beyond them: it clarifies this is only a local/config check and does not authenticate to providers or certify upstream availability, which prevents false expectations of a live connectivity test. It stops short of describing what the readiness result looks like.

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

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

Two tight sentences with the positive scope front-loaded and the negative scope immediately after. Every clause earns its place with no filler.

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

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

For a parameterless diagnostic with read-only annotations and no output schema, the description covers what it inspects and its limits. It would be fully complete only with a hint about the readiness signal it returns, but nothing needed to invoke it correctly is missing.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. No schema detail is lost.

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 and two concrete resources: registered source configuration and the local Tor SOCKS proxy. It is distinguishable from siblings like darknet_list_sources or tor_status, though it doesn't explicitly contrast itself with the closely related tor_status/darknet_investigate tools.

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

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

Usage is implied (a pre-flight readiness check before running darknet queries), and the closing clause usefully scopes out what it does NOT do. However, it never states when to prefer this over siblings like tor_status or darknet_investigate, so the agent must infer the context.

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

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

Annotations already declare readOnlyHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds that the result is a 'simplified classification', but says nothing about rate limits, API key requirements, or what 'simplified' omits relative to a full lookup.

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 zero waste, front-loading the core question before the return note. Appropriately sized for a single-parameter lookup tool.

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

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

For a simple read-only, single-parameter tool with full annotation coverage, the description conveys the query and the shape of the answer. It stops short of explaining the classification values, which matters slightly given there is no output schema.

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

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

Only one parameter, and schema coverage is 100% with the schema already describing it as 'IP address to check'. The description adds no extra meaning such as accepted formats or normalization behavior, so baseline 3 applies.

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

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

States a specific verb and resource ('GreyNoise check' on an IP) plus the question it answers (known scanner vs known benign service). The words 'Quick' and 'simplified' imply a lightweight variant of a fuller lookup, but it never names the sibling 'greynoise_ip', so the distinction is left implicit.

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?

'Quick' and 'Returns simplified classification' imply a fast triage use case, but there is no explicit when-to-use or when-not-to-use guidance. Notably, the sibling 'greynoise_ip' is never mentioned as the alternative for full detail.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful context beyond the annotations: the returned fields (classification, scanner status, last-seen) and that it is free with no API key, which matters for an agent deciding whether the call will succeed.

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, front-loaded with the action and API, followed by return content and access constraints. Every sentence carries distinct, useful information with no padding.

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

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

With no output schema, the description correctly compensates by enumerating the returned fields. It is nearly complete for a simple single-param lookup, though it omits any note on rate limits, error/not-found behavior, or result freshness beyond 'last seen timestamp'.

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

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

Schema description coverage is 100% for the single 'ip' parameter, so the schema already documents it. The description adds no syntax, format, or edge-case detail beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb (look up) and resource (IP address) plus the backing API, so the agent knows exactly what it does. However, it does not differentiate from close siblings like greynoise_check or abuseipdb_check/otx_ip, which also perform IP reputation lookups.

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?

No when-to-use, when-not-to-use, or alternative-selection guidance is given, despite a crowded field of IP-reputation siblings (greynoise_check, abuseipdb_check, otx_ip, pulsedive_indicator, tor_exit_check). The agent must guess which IP tool is appropriate.

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

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

Annotations already declare readOnlyHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful non-annotation context: it is asynchronous (returns a search ID, not results) and requires INTELX_API_KEY for authentication.

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, the search scope front-loaded and the async/auth constraints trailing. Every clause carries information; nothing is redundant with the schema or annotations.

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, and the description compensates by stating the return is a search ID rather than result data, plus the API key prerequisite. With 100% schema coverage and annotations covering safety, an agent has nearly everything needed; only the follow-up tool for fetching results is unstated.

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

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

Schema description coverage is 100%, so the schema already documents 'term', 'target' (with value meanings) and 'max_results' with defaults and bounds. The description's mention of 'emails, domains, URLs' loosely maps to the target enum but adds no syntax or format guidance, so the baseline 3 is correct.

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 ('Initiate a phonebook search on IntelligenceX') and describes the covered data types (emails, domains, URLs). 'Initiate' plus 'Returns search ID' makes the async two-step nature explicit, which distinguishes it from the plain intelx_search sibling, though it never names a sibling outright.

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 'Returns search ID' implies the intended workflow (initiate here, then collect results via intelx_phonebook_results), but no alternative or when-not-to-use condition is stated. Usage is inferable rather than spelled out, and the relationship to intelx_search is left ambiguous.

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

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

Annotations already declare readOnlyHint and openWorldHint. The description adds the prerequisite tool and auth requirement (INTELX_API_KEY), which annotations do not convey. Return format is undocumented but no output schema exists, so this is a meaningful addition.

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 front-load the action, then give the prerequisite and auth requirement. No waste.

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?

Covers the dependency, auth, and identification requirements for a simple read retrieval tool with no output schema and full param coverage. Pagination behavior for limit/offset is left to the schema, which is adequate but slightly thin.

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 id, limit, and offset are already fully documented. The description adds no format or paging semantics beyond what the schema provides, making baseline 3 correct.

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 (Retrieve) and resource (phonebook search results) plus the source (IntelligenceX) and the keying parameter (by ID). It names the sibling it depends on, distinguishing it from intelx_phonebook and intelx_search_results.

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

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

Explicitly tells the agent to use it after intelx_phonebook, giving clear sequencing. It does not name when NOT to use it or contrast with intelx_search_results, but the dependency 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds genuinely useful non-schema behavior: this is an asynchronous initiation returning a search ID, and it requires INTELX_API_KEY for auth.

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 action and scope, followed by the return contract and auth requirement. Nothing is wasted and no clause is redundant.

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 correctly discloses the return value (search ID) and the async follow-up path, plus the API key prerequisite. It is nearly complete for a 2-param tool, though the absence of any when-not-to-use note leaves a small gap.

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

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

Schema description coverage is 100%, so both parameters (term, max_results) are already fully documented in the schema. The description adds no syntax, format, or constraint detail beyond what the schema provides, so the baseline 3 applies.

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

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

Names a specific verb (Initiate) and resource (search on IntelligenceX) plus the data domain (leaked data, dark web). Implicitly separates itself from intelx_search_results by stating it returns a search ID rather than results, though it never names that sibling directly.

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 'Returns a search ID to retrieve results' implies the two-step async workflow, which is useful context, but there is no explicit when-to-use guidance or comparison against alternatives like intelx_phonebook or the sibling result tools.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a genuinely useful non-annotation detail (requires INTELX_API_KEY), but says nothing about pagination behavior or the shape/nature of returned results.

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

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

Two tight sentences with zero waste. The core action and its dependency are front-loaded, and the auth requirement is a concise trailing note.

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

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

For a read-only tool whose annotations carry the safety profile and whose schema fully documents pagination, the description supplies the essential workflow context and auth requirement. Return-format detail is largely unnecessary given the nature of the operation, though a note on result volume/paging would round it out.

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

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

Schema description coverage is 100%, so id, limit, and offset are already fully documented in the schema. The description only echoes that the ID comes from intelx_search, adding no syntax or format detail beyond the structured fields, 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 states a specific verb (Retrieve) and resource (results for an IntelligenceX search by ID), and implicitly distinguishes itself from the sibling intelx_search which initiates the search. An agent can tell this is the retrieval half of a two-step flow without opening the schema.

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

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

'Use after intelx_search to get actual data' gives explicit sequencing context that selects this tool over its sibling. It stops short of naming when-not conditions or alternative result paths, but the triggering context is clear.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower. The description adds genuine extra context: the upstream source is Hybrid Analysis, the payload contains verdicts, and it discloses the HYBRID_API_KEY credential requirement. It omits any rate-limit, pagination, or freshness-window detail.

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 short sentences, front-loaded with the action and resource, then return content, then the auth prerequisite. 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 zero-parameter read-only feed with no output schema, the description covers what is fetched, from where, what comes back (recently analyzed samples with verdicts), and the credential needed. Nothing an agent requires to invoke it correctly is missing.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to disambiguate, and it correctly avoids inventing parameter talk.

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

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

States a specific verb and resource ('Get the latest malware detonation feed') and names the source system, Hybrid Analysis. This differentiates it reasonably well from generic siblings like malware_search or malware_overview, though it does not explicitly contrast itself with other recent-sample tools such as bazaarRecent.

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: 'latest ... feed' signals you call this when you want recent samples rather than a targeted lookup. There is no explicit when-not guidance and no alternative named, despite many overlapping siblings (malware_search, malware_overview, bazaarRecent).

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

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

The annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context: it requires HYBRID_API_KEY and enumerates the return categories (MITRE ATT&CK techniques, network indicators, processes, extracted files). It does not mention rate limits, caching, or handling of unknown hashes, 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?

Three tightly written sentences: purpose first, then return contents, then the authentication prerequisite. Nothing is redundant, and each sentence adds material value for an agent or developer.

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, read-only lookup with no output schema, the description is nearly complete: it covers purpose, provider, input, auth requirement, and return categories. It leaves minor gaps around failure behavior and data freshness, but an agent has enough to invoke it correctly.

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

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

Schema coverage is 100%, and the single sha256 parameter is fully described with a pattern in the schema. The description repeats that the input is a SHA256 hash but adds no format, normalization, or validation detail beyond what the schema already provides. This matches the baseline 3 when the schema does the heavy lifting.

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: retrieve a full malware analysis overview from Hybrid Analysis for a SHA256 hash. It differentiates itself from generic siblings like malware_search by naming the provider and the 'overview' scope. However, it does not explicitly name an alternative tool or explain why an agent should choose this over otx_hash or bazaarHash.

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: the agent should call this when it has a SHA256 hash and wants hybrid-analysis malware reporting. There is no explicit statement of when to prefer this tool over sibling hash-lookup tools, nor any exclusion criteria. The context is clear enough to infer the basic use case but stops short of routing guidance.

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

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

Annotations already declare readOnly, non-destructive, open-world behavior, so the safety profile is covered. The description adds genuinely useful context beyond that: it names the authentication precondition (HYBRID_API_KEY) and previews the return payload (verdict, AV detection rate, analysis details), which matters since there is no output schema.

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

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

Three short sentences, each carrying distinct information: scope, return shape, and prerequisite. The most important fact (what it searches) is front-loaded with zero 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 one-parameter read-only lookup, the description covers purpose, input domain, auth requirement, and return contents, and annotations cover the safety profile. Only the routing guidance versus sibling hash lookups is missing.

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

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

Schema coverage is 100% and the single parameter carries a regex pattern plus description, so the schema does the heavy lifting. The description only restates the accepted hash algorithms, adding no syntax or format detail beyond the schema.

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

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

States a specific verb (Search), a specific resource (Hybrid Analysis sandbox), and the exact input type (file hash). It is clearly distinguishable from siblings like bazaarHash, otx_hash, and malware_overview, which cover different sources or the broader overview case.

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

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

The description makes usage implied by naming the accepted hash types and the required HYBRID_API_KEY, but it never says when to prefer this tool over alternative hash lookups such as bazaarHash or otx_hash, nor when it is inappropriate (e.g., non-hash indicators).

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

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

Annotations already declare readOnlyHint true, destructiveHint false, and openWorldHint true, covering the safety profile. The description adds the useful fact that it returns certificates, ports, and associated Bitcoin addresses, which exceeds annotation info, but says nothing about rate limits, source reliability, or caching.

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: what it does and what it returns. Front-loaded with the verb and resource, 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?

Adequate for a simple single-param read tool with rich annotations. However, with no output schema, the description lists return fields but doesn't explain their shape or reliability, and omits any usage context among many sibling Tor tools.

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

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

Schema coverage is 100% and the single parameter is fully documented there. The description adds no parameter syntax but has zero parameters to compensate for, so baseline 4 is correct per the rules.

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?

Clear verb (look up) plus specific resource (metadata for a .onion address) and names the data source (CIRCL AIL). It distinguishes itself from siblings like tor_scrape_onion or tor_fetch_onion by focusing on metadata retrieval, though it doesn't explicitly say so.

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?

No when-to-use guidance. With many Tor-related siblings (tor_scrape_onion, tor_fetch_onion, tor_status, tor_search_onion), the description never explains when to pick this tool versus the alternatives.

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

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

Annotations already declare the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower. The description adds genuinely new context by disclosing the return contents ('related pulses and indicators'), which matters because no output schema exists — though it says nothing about auth requirements or rate limits on the OTX API.

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, zero filler, with the purpose front-loaded and the return-content note second. Nothing repeats the tool name or the schema.

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

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

For a single-parameter, read-only lookup with rich annotations and no output schema, the description covers purpose and return shape adequately. Minor gaps remain around preconditions (valid CVE format, API key/availability) and response structure, but nothing that would cause a mis-invocation.

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

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

There is a single parameter with 100% schema description coverage; the schema itself supplies the CVE-ID pattern and an example (CVE-2024-1234). The description adds no additional semantics about the parameter, 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?

States a specific verb and resource ('Look up threat intelligence for a CVE') plus the backing source ('via AlienVault OTX'). The CVE resource focus clearly separates it from sibling tools scoped to IPs, domains, hashes, and pulses (otx_ip, otx_domain, otx_hash, otx_search_pulses).

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: reach for this when you hold a CVE ID and want enrichment. There is no explicit 'use this when / use X instead' routing, no mention of the required CVE-ID format as a precondition, and no exclusion cases relative to vulners_id or threatfoxSearch.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by naming the returned data categories ('pulse info, whois, reputation'), which is valuable since no output schema exists. It still omits rate limits or error behavior, but adds meaningful value beyond structured fields.

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

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

Two short sentences with zero waste: the first front-loads the purpose, and the second efficiently summarizes the return contents. 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 simple read-only lookup with one fully documented parameter and annotations covering safety, the description is nearly complete. It compensates for the missing output schema by naming return categories, though it could better distinguish itself from sibling indicator tools like otx_ip or otx_search_pulses.

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

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

Schema description coverage is 100% for the single 'domain' parameter, so the schema already documents the parameter with an example. The description adds no additional parameter semantics beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description states a specific verb ('Look up') and resource ('threat intelligence for a domain'), making the tool's core purpose immediately clear. It does not explicitly differentiate itself from sibling tools like otx_ip, otx_hash, or otx_search_pulses, but the domain resource is inherently distinct.

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 tool versus alternatives such as otx_search_pulses or otx_ip, nor any stated prerequisites or exclusions. The intended usage is implied by the resource, but the description provides no explicit when-to-use context.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety and external-call profile is covered. The description adds the provider and accepted hash types but says nothing about rate limits, authentication, or what the lookup returns, so it adds only modest context.

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

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

Two short sentences, front-loaded with the action and resource. The second sentence is slightly redundant with the schema's pattern, but the whole definition is compact and wastes little.

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, read-only lookup with a fully described schema and annotations covering the safety profile, the description is complete enough to invoke the tool correctly. With no output schema, a brief note on return content would be nice, but nothing essential is missing.

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

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

Schema description coverage is 100% and the single parameter is fully documented with a regex pattern enforcing the MD5/SHA1/SHA256 lengths. The description's 'Supports MD5, SHA1, SHA256' merely restates what the schema already conveys, so the baseline 3 applies.

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

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

States a specific verb (look up) and resource (threat intelligence for a file hash) plus the data source (AlienVault OTX), so the agent knows exactly what it does. However, it does not differentiate itself from sibling hash/intel lookups such as bazaarHash or threatfoxGetIocs, which could also serve a hash-based query.

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?

Naming AlienVault OTX as the source implies when this tool is the right choice versus other providers, but there is no explicit when-to-use, when-not-to-use, or alternative routing guidance. Usage is only inferable from the provider name.

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

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

Annotations already declare readOnly=true, openWorld=true, and destructive=false, so the safety profile is covered. The description adds useful return-content context (pulse info, reputation, country, ASN), which matters because there is no output schema. It does not disclose rate limits, auth requirements, or error behavior.

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

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

Two tight sentences with the purpose front-loaded and zero filler. The return-field list is compact and informative, though a slightly terser form could have folded it 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?

For a single-parameter lookup with full annotation coverage and no output schema, the description covers purpose, source, and expected return fields adequately. The main omission is routing guidance among the many overlapping IP-intel siblings.

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?

Only one parameter with 100% schema description coverage, so the schema carries the semantics. The description adds nothing about the input beyond the resource type; baseline 3 is appropriate. Note the schema itself is slightly inconsistent (fields allow ipv4/ipv6 but description text says 'IPv4 address'), though that is a schema issue rather than a description 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?

States a specific verb ('Look up') and resource ('threat intelligence for an IP address') with the data source ('AlienVault OTX'), clearly distinguishing it from otx_domain, otx_hash, and otx_cve. However, it does not distinguish itself from the many other IP-intel siblings (greynoise_ip, abuseipdb_check, pulsedive_indicator), which is where an agent most needs routing help.

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?

No when-to-use guidance and no stated alternatives. An agent facing greynoise_ip, abuseipdb_check, pulsedive_indicator, and threatfoxGetIocs cannot tell from this description why it should prefer otx_ip or in what situation OTX data is the right 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?

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower. The description adds genuinely useful context by disclosing the return shape — tags, malware families, IOC counts — which matters because no output schema exists. It omits rate limits, pagination, and auth requirements.

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

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

Two sentences, zero filler, with the action and scope front-loaded ahead of the return summary. 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 two-parameter read-only search with no output schema, the description covers purpose, scope, and return fields adequately, and annotations carry the safety profile. Minor gaps remain around result ordering and whether `limit` truncates silently.

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

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

Schema description coverage is 100%, with both `query` and `limit` documented in the schema, so the baseline is 3. The description's 'by keyword' adds slight clarity on how `query` is matched but no syntax, operators, or formatting guidance.

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 (search) and resource (AlienVault OTX threat pulses) scoped by keyword, which clearly distinguishes it from the indicator-lookup siblings otx_ip/otx_domain/otx_hash/otx_cve. It does not explicitly name a sibling or contrast the two modes, so it stops short of the top tier.

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: an agent can infer you call this when you have a keyword rather than an indicator. There is no explicit when-to-use, when-not-to-use, or named alternative, and no prerequisites are mentioned.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), and the description is consistent with them by naming an external service. It adds useful return semantics (presence in database + verification flag) but omits any mention of latency or rate limits on the PhishTank lookup.

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 the action and source, with zero filler. Nothing could be removed without losing 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 one-parameter read-only lookup with no output schema, the description covers the essential return values (membership and verification status). It could say slightly more about the return shape or what an unverified hit means, but it is essentially 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?

There is a single parameter with 100% schema description coverage ('URL to check for phishing'), so the schema carries the semantics. The description adds no format or normalization guidance beyond what the schema already states, making the baseline 3 appropriate.

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

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

States a specific verb ('Check'), a specific resource ('a URL'), and the backing data source ('via PhishTank'), which distinguishes it from sibling URL-lookup tools like urlhausLookup. An agent can tell immediately what this does.

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

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

The purpose implies the use case (screening a URL for phishing), but there is no explicit when-to-use guidance, no exclusions, and no pointer to alternatives such as urlhausLookup or pulsedive_indicator for broader URL/indicator checks.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds the output trait (returns related IOCs with risk levels), but says nothing about query cost, rate limits, or result 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?

Two short sentences with the core purpose front-loaded and no filler. Efficient, though the second sentence is somewhat generic ('related IOCs with risk levels').

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 one required parameter, no output schema, and annotations covering the safety profile, the description is nearly adequate. It omits any hint of how results are shaped, paginated, or bounded, which mildly matters for an open-world exploration tool.

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

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

Schema coverage is 100% and the single query parameter already carries an example syntax ('ioc=...' or 'threat=...'). The description's 'advanced queries' phrase adds no syntax or format detail beyond what the schema provides, 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?

Specific verb (Explore) plus resource (linked indicators on Pulsedive) and an output hint (related IOCs with risk levels). It is clear what the tool does, but it never distinguishes itself from its close siblings pulsedive_search and pulsedive_indicator, leaving the agent to infer the boundary.

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 and no mention of when to prefer pulsedive_search or pulsedive_indicator instead. 'Advanced queries' implies a differentiation but never states the condition that selects this tool over its siblings.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds the shape of the response (risk level, threats, feeds, properties), which is useful, but says nothing about rate limits, authentication, or behavior on unknown indicators.

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, zero waste, with the action and accepted input types front-loaded ahead of the return-value summary. Nothing could be removed without losing information.

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

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

For a single-parameter read tool with no output schema, the description covers purpose, accepted inputs, and return content, and annotations carry the safety profile. It stops short of error behavior or rate-limit notes, but nothing critical to correct invocation is missing.

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

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

Schema description coverage is 100% for the single 'indicator' parameter, and the description merely restates the same accepted types (IP, domain, URL, hash). It adds no format or syntax detail beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (look up) and resource (indicator: IP, domain, URL, or hash) on a named platform, and previews the returned fields. It does not explicitly distinguish itself from sibling tools like pulsedive_search or pulsedive_explore, so an agent must infer that this is the single-indicator lookup versus a keyword 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?

The phrase 'look up an indicator' implies usage for a known indicator value, which is reasonable guidance for a one-required-param lookup. However, it never states when to prefer this over pulsedive_search or pulsedive_explore, and gives no exclusions or prerequisites, leaving routing to inference.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the return shape ('matching indicator IDs') which is genuinely useful given no output schema, but it says nothing about rate limits, auth, or token requirements expected of an open-world search API.

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

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

Two tight sentences with zero filler, and the core purpose is front-loaded. It is efficient, though the extreme brevity leaves no room for routing or format hints.

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 read tool with annotations covering safety and no output schema, the description covers purpose and return shape. It omits the two things most needed here: how to phrase the query value and when to prefer the sibling Pulsedive tools.

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

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

Schema coverage is 100% and the single 'query' parameter is documented in the schema, so the baseline is 3. The description's 'by value' adds a little meaning (searching on the indicator value itself) but no syntax, format, or example beyond what the schema provides.

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

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

States a specific verb and resource ('Search Pulsedive indicators by value') and clarifies the query operates on indicator values. It does not differentiate from the sibling tools pulsedive_indicator and pulsedive_explore, so an agent can't tell from the description alone which Pulsedive lookup to pick.

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 mention of the sibling alternatives (pulsedive_indicator for known indicators, pulsedive_explore for pivoting). 'By value' hints at the query form but no conditions or exclusions are given.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds genuinely useful behavioral scope beyond that: the public endpoint returns names only and supplies no URLs or profiles, which sets expectations for the result shape.

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, and the core purpose plus the scope limitation are front-loaded in order of importance.

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, but the description compensates by stating what the return contains (names only) for this simple parameterless list call. The one gap is the lack of disambiguation from the sibling ransomwareGroups.

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; there is nothing for the description to disambiguate beyond the return-content note it already provides.

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

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

States a specific verb and resource ('List the ransomware group names tracked by RansomLook') and pins the data source, which helps distinguish it from the similarly named sibling ransomwareGroups. However, it never explicitly contrasts itself with that near-duplicate sibling, leaving the agent to guess which group-listing tool to pick.

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: the note that the endpoint returns names only implies you should look elsewhere if you need URLs or profiles, but no alternative tool is named and no when/when-not condition is stated. For a catalog with several overlapping ransomware-group tools, this is thin routing guidance.

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

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

Annotations already establish readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety and reach are covered. The description adds a useful return-field list (group name, post title, URL, discovery timestamp) that matters because no output schema exists, but it omits volume, pagination, or freshness window.

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 waste, with the core action front-loaded ahead of the return-value detail. Efficient and appropriately sized for a no-arg fetch tool.

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

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

For a zero-parameter, read-only feed reader with annotations covering its safety profile, the description supplies the source and the returned fields, which is nearly everything needed to call it. It would be complete only if it added scale or time-window details.

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. There is no parameter surface for the description to clarify or for the schema to leave undocumented.

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

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

States a concrete verb ('Fetch'), resource ('most recent ransomware posts and victim claims'), and source ('from RansomLook'). It is clear on its own but does not distinguish itself from the sibling 'ransomwareRecent', which appears to cover the same ground, 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?

The description never says when to use this tool versus alternatives such as ransomwareRecent, ransomwareSearch, or ransomlookGroups. There is no context, trigger condition, or exclusion, leaving the agent to infer 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, so the safety profile is covered. The description adds the country-filter semantics but says nothing about pagination, result ordering, or data freshness beyond what the schema states. Adequate given the 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?

Two compact sentences: the core action front-loaded, followed by a short list of example codes. Every element earns its place with no filler.

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

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

For a read-only, filtered-list tool with no output schema and fully documented parameters, the description covers what an agent needs to call it correctly. The only minor gap is that return content ('victims') is never characterized, but the annotation set and schema carry most of the load.

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

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

Schema description coverage is 100%, so countryCode, limit, and offset are fully documented in the schema, including the same ISO 3166-1 examples. The description merely restates the countryCode semantics, adding no meaning beyond the schema. Baseline 3 applies.

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

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

States a specific verb+resource+scope: 'Get ransomware victims filtered by country'. This is distinguishable from siblings like ransomwareBySector and ransomwareRecent by its country filter. It stops short of naming alternatives, but the resource and filter are 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?

Usage is implied by the country-filter scope, and the required countryCode makes the entry condition obvious. However, with many ransomware siblings (ransomwareSearch, ransomwareBySector, ransomwareGroups), the description gives no explicit when-to-use/when-not guidance or alternatives.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds only example sector strings, not behavioral context such as data source, pagination behavior, rate limits, or result shape.

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 core purpose front-loaded and no filler. Every phrase 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 simple filtered-list tool with full parameter documentation and clear safety annotations, the description is largely sufficient. It could mention the shape of returned victim records or that results are paginated, but those omissions are minor given the schema and annotations.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's sector examples duplicate the schema's own sector examples and add no new meaning for limit, offset, or sector beyond what is already documented.

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

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

States a specific verb and resource ('Get ransomware victims filtered by sector or industry') and gives concrete sector examples. It does not explicitly distinguish itself from close siblings like ransomwareByCountry or ransomwareSearch, 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?

The description gives no when-to-use guidance, no prerequisites, and no alternatives. It only restates the filter dimension and lists example values, leaving the agent to infer when this tool beats ransomwareSearch or ransomwareByCountry.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds value beyond that by enumerating the returned content (description, known URLs, locations, profile metadata), which matters since no output schema exists. It stops short of describing behavior for an unknown or ambiguous group name.

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

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

Two tight sentences with the verb and scope front-loaded and no filler. The second sentence earns its place by listing return contents, though 'profile metadata' is vague makeweight rather than useful detail.

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

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

For a one-parameter read-only lookup with full schema coverage and annotations covering the safety profile, the description supplies what is otherwise missing: the shape of what comes back. No output schema is present, so that enumeration is the key gap it closes.

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

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

Schema description coverage is 100% and the single 'name' parameter already carries a description with concrete examples ('lockbit3', 'clop', 'blackcat'). The description adds no syntax, casing, or matching-semantics detail beyond what the schema provides, so the baseline 3 applies.

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

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

The description states a specific verb and resource ('Get a detailed profile for a specific ransomware group by name'), which lets an agent distinguish it from the list-style siblings such as ransomwareGroups. It does not explicitly name any sibling, so the differentiation is implicit 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?

'By name' implies the tool is used when a group name is already known, but there is no explicit when-to-use/when-not guidance and no routing to alternatives like ransomwareSearch, ransomwareGroupVictims, or ransomlookGroups for overlapping needs. Usage is inferable but not 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?

Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description usefully adds the data source (ransomware.live) and the shape of the payload, but says nothing about pagination behavior, rate limits, or how current the tracked-group list is. Adds some value above annotations, not rich context.

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

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

Two tight sentences with zero padding; the operation and the return contents are front-loaded. Slightly more efficient than the norm, but nothing exceptional in structure.

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

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

With no output schema, the description compensates by naming the returned fields (names, descriptions, onion URLs, profile info), which is enough for an agent to know what it gets back. The only gap is that the 'all' framing obscures the default 100-item page size, a minor omission for a simple read.

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

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

Schema description coverage is 100% (limit 1-200 default 100, offset for the cached response), so the schema fully documents both parameters. The description adds no paging guidance — notably it says 'List all' without noting the default 100-record cap — so baseline 3 is correct.

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+resource: 'List all known ransomware groups tracked by ransomware.live', with a clear enumeration of returned fields. It implicitly separates itself from the singular ransomwareGroup sibling by being the bulk-list variant, but never names siblings explicitly, so it stops short of top marks.

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?

No when-to-use or when-not-to-use guidance. Critically, the sibling ransomlookGroups appears to be a near-identical 'list all groups' tool from a different provider, and the description never explains why an agent would pick one over the other. Nothing about prerequisites or result-set scope either.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the shape of the returned data, which is useful given there is no output schema, but it says nothing about pagination behavior despite limit/offset parameters, nor about name-matching semantics.

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, zero filler, with the core action front-loaded and the return payload immediately after. 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 simple read-only lookup with a fully documented schema, the description covers the action and the return fields, which is most of what an agent needs given the annotations carry the safety profile. It stops short of explaining pagination or how the group name must be formatted/matched, but those gaps are minor.

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

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

Schema description coverage is 100%: the schema documents the required group name with examples ('lockbit3', 'clop', 'blackcat') and both pagination parameters fully. The description adds no parameter-level detail beyond the schema, 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?

States a specific verb ('Get') and resource (victims claimed by a named ransomware group), and the summary of returned fields (names, countries, sectors, publication dates) makes the intent unambiguous. It does not, however, distinguish itself from closely named siblings like ransomwareGroup, ransomwareGroups, or ransomwareSearch, leaving the agent to infer the difference from the name alone.

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

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

The description gives no guidance on when to use this tool versus the many sibling ransomware tools (ransomwareGroup, ransomwareRecent, ransomwareByCountry, ransomwareBySector, ransomwareSearch). There are no prerequisites, no exclusions, and no routing hints — the agent must guess from the name alone.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true (external network call), so safety is covered. The description adds real value by disclosing the returned fields (victim name, group, country, sector, publication date, URLs), which matters because there is no output schema. It omits pagination behavior, though offset/limit are schema-documented.

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, zero filler, with purpose and return shape front-loaded. 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 simple, non-mutating feed tool with annotations covering safety and no output schema, the description supplies the essential missing piece: the return shape. Pagination via limit/offset is left to the schema, which documents it adequately, so the definition is nearly complete.

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

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

Schema description coverage is 100%, and both limit and offset are fully documented in the schema with ranges and defaults. The description adds nothing about parameter meaning, which is acceptable at this coverage level but not enriching.

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 ('fetch the most recent ransomware victims') and names the data source (ransomware.live), which distinguishes it from vendor-agnostic siblings. It stops short of explicitly differentiating the 'recent' feed from siblings like ransomwareSearch, ransomwareByCountry, or ransomwareBySector.

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 word 'most recent' implies a recency-feed use case, but there is no explicit when-to-use guidance and no named alternative. Given the dense cluster of ransomware siblings (ransomwareGroup, ransomwareSearch, ransomwareByCountry, ransomwareBySector, ransomlookRecent), an agent gets no help choosing between them.

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

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

Annotations already declare this a read-only, non-destructive, open-world operation, so the safety profile is covered. The description usefully notes that matching spans victim names, descriptions and other fields (fuzzy multi-field search behavior), but says nothing about pagination, result ordering, or the impact of the offset/limit caching behavior.

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

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

Two short sentences, front-loaded with the primary action before the use case. Every clause earns its place with no redundancy.

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

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

For a read-only search tool with a fully documented schema, complete annotations, and no output schema, the description covers the essentials. Minor gaps remain: no indication of result format, ordering, or how the cached-response offset behaves.

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

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

Schema description coverage is 100%, with limit, offset and keyword all documented in the schema, so the baseline of 3 applies. The description mentions what the keyword matches against but adds no syntax, formatting, or paging semantics beyond the schema.

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

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

The description states a specific verb and resource ("Search ransomware victims by keyword") and clarifies the search scope (victim names, descriptions, other fields). It is clear but does not explicitly distinguish itself from the many ransomware siblings like ransomwareRecent or ransomwareGroupVictims.

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?

"Useful for checking if a specific company has been listed as a victim" gives one concrete usage scenario, so usage is implied rather than spelled out. It offers no when-not guidance and does not point to alternative tools such as ransomwareRecent for recent listings or ransomwareGroupVictims for group-scoped queries.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), and the description adds the API-key authentication requirement plus the shape of the returned data (compromised machines, credentials, malware details). It does not mention rate limits or pagination behavior, but the added auth and return-content context is meaningful.

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 short sentences with no redundancy: purpose and scope first, return contents second, prerequisite last. Every sentence carries distinct information and nothing is padded.

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 previews the returned fields and states the required API key, which is the main operational prerequisite. The only gap is pagination guidance around the cursor, which is a minor omission for a 2-parameter read tool.

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

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

Schema description coverage is 100%, so both parameters (domain, cursor) are already documented in the schema with format examples and length bounds. The description adds no syntax, format, or cursor-usage detail beyond that, 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?

States a specific verb (Search), resource (stealer log entries), source (Hudson Rock Cavalier), and scoping key (by domain), plus what the result contains. The 'by domain' framing cleanly separates it from the sibling stealer_email and stealer_ip tools.

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

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

Usage is implied by the 'by domain' scope, which tells an agent this is the domain-oriented variant among the stealer_* siblings. However, there is no explicit when-to-use statement, no exclusions, and no guidance on when to prefer stealer_email or stealer_ip instead.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new context beyond annotations: the return content (compromised machines with the email in browser credentials) and the API key requirement. Pagination is not discussed despite the cursor parameter.

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 tightly packed sentences with zero waste, front-loaded with the action and data source before the return semantics and prerequisite. Every sentence 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 exists, so the description appropriately explains what is returned (compromised machines with matching browser credentials). The only gap is pagination/cursor behavior, which the cursor parameter documents externally; the definition is otherwise complete for a 2-param search tool.

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

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

Schema description coverage is 100%, so the schema already documents both 'email' and 'cursor' with formats and constraints. The description adds no syntax or format detail beyond the schema; baseline 3 applies when the schema does the heavy lifting.

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 (Search), the exact resource (Hudson Rock Cavalier stealer logs), and the search axis (by email address), plus what it returns. It does not explicitly distinguish itself from the closely named siblings stealer_domain and stealer_ip, though the 'by email' phrasing implies the axis distinction.

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

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

The tool's purpose implies when it applies (looking up stealer-log exposure for a specific email) and it states the HUDSONROCK_API_KEY prerequisite. However, it offers no explicit when-to-use/when-not guidance or routing to the stealer_domain/stealer_ip siblings for other indicator types.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds value beyond them by disclosing the auth requirement ('Requires HUDSONROCK_API_KEY') and the nature of the result set ('compromised machines'). It does not mention rate limits or pagination behavior, though the cursor parameter implies paging.

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 short sentences, zero filler, and the core action is front-loaded in the first sentence. The return behavior and auth requirement each appear once and earn their 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 read-only search tool with two parameters and no output schema, the description covers the action, the return content, and the auth prerequisite. It is nearly complete; only pagination behavior (via cursor) and any result limits are unaddressed.

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

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

Schema description coverage is 100%, so both the 'ip' and 'cursor' parameters are already documented with format constraints and the cursor's origin. The description adds no parameter-specific syntax or format guidance, so the schema carries the full load and 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?

States a specific verb and resource: 'Search Hudson Rock Cavalier stealer logs by IP address,' with a clear scope of what it returns ('compromised machines originating from that IP'). It does not explicitly name the sibling tools (stealer_domain, stealer_email) or distinguish this tool from them, but the IP-specific framing makes the distinction inferable.

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 IP-based framing and the sibling family (domain/email variants), so an agent can infer this is the IP-keyed lookup. However, there is no explicit statement of when to use this versus stealer_domain/stealer_email, nor any exclusions or prerequisites beyond the API key.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds a useful auth requirement (ABUSECH_AUTH_KEY) and recency scope, but does not disclose pagination, rate limits, result size limits, or return structure.

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 short sentences with zero wasted words. Purpose is front-loaded, followed by return scope and the auth prerequisite in a logical sequence.

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 one-parameter, read-only retrieval tool with full schema coverage and safety annotations, the description covers source, scope, and authentication. It is nearly complete, though it omits return-format details that could help with an absent output schema.

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

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

Schema description coverage is 100%, so the 'days' parameter is fully documented with type, default, and range in the schema. The description only repeats 'last N days' and adds no syntax, filtering, or format detail beyond the schema.

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

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

States a specific verb and resource ('Get recent IOCs from ThreatFox'), names the source (abuse.ch), and defines the scope ('last N days'). However, it does not distinguish from sibling tools threatfoxSearch, threatfoxTag, or threatfoxMalware, leaving an agent to infer which ThreatFox endpoint fits a given query.

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

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

Provides no when-to-use guidance, exclusions, or alternatives for selecting this over sibling ThreatFox tools. The only prerequisite mentioned is ABUSECH_AUTH_KEY; there is no context about when recent IOC retrieval is appropriate versus searching by tag or malware.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description usefully adds the ABUSECH_AUTH_KEY requirement, which the annotations do not convey, but says nothing about result format or pagination.

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

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

Two tight sentences with zero waste; the core purpose is front-loaded and the auth prerequisite closes it without padding.

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

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

For a read-only search tool with full schema coverage and annotations carrying the safety profile, nothing critical is missing. The auth requirement is disclosed, and no output schema exists to explain further.

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

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

Schema coverage is 100%, so both parameters are already documented with the Malpedia format example. The description repeats that same naming convention rather than adding syntax or format details beyond the schema, so the baseline 3 is correct.

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 (Search), resource (ThreatFox IOCs) and scope (by malware family), which an agent can distinguish from threatfoxSearch and threatfoxTag. It does not name those siblings explicitly, so it falls short of the 5 bar for 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?

The 'by malware family' phrasing implies when to use this over a general ThreatFox search, but no explicit when/when-not or alternative tool is named. Usage is left largely to inference.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the ABUSECH_AUTH_KEY requirement, which is genuinely useful context, but says nothing about result volume, rate limits, or whether lookups are billed/throttled.

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 short sentences: capability first, accepted inputs second, prerequisite last. Every sentence carries information and there is zero 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 single-parameter read-only search with no output schema, the description covers what it does, what inputs it takes, and the auth requirement. The only real gap is the absence of routing guidance against the many sibling lookups, which is a usage-guideline issue more than a completeness one.

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

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

Schema description coverage is 100% and the single parameter is fully documented in the schema. The description restates the same accepted input types (IP, domain, MD5/SHA256, URL) without adding syntax, formatting, or matching-behavior details the schema lacks, so baseline 3 applies.

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

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

States a specific verb (Search) and resource (ThreatFox IOCs) and enumerates the accepted indicator types, so the agent knows exactly what it queries. It does not differentiate itself from siblings like threatfoxGetIocs, threatfoxTag, or threatfoxMalware, leaving the IOC-vs-tag-vs-malware split 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 explicit when-to-use guidance, no when-not-to-use, and no named alternative despite several closely related threatfox siblings. The agent must infer that a term-based lookup differs from threatfoxGetIocs or threatfoxTag purely from the name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description usefully adds that ABUSECH_AUTH_KEY is required, a real behavioral constraint, but says nothing about rate limits, result caps behavior, or return shape.

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 clauses, front-loaded with the action and resource, and the auth requirement appended without padding. Slightly terse but no wasted sentences.

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

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

For a low-complexity read-only search with full schema coverage, the essentials are present, but with no output schema the description should say something about what comes back (IOC records, fields, volume). The missing return-shape context is the main gap.

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

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

Schema description coverage is 100%, so both parameters (tag and limit, including its 1-1000 range and default) are already fully documented in the schema. The description only restates the tag concept with examples, adding nothing beyond what the schema provides — baseline 3.

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 (search) and resource (ThreatFox IOCs) with the scoping key (tag), which is enough to distinguish it from sibling tools like threatfoxSearch or threatfoxGetIocs. It does not name those siblings explicitly, so it stops short of a 5.

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

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

The description gives no when-to-use context and no alternatives — it never explains how this differs from threatfoxSearch, threatfoxMalware, or threatfoxGetIocs, all of which are plausible lookups in the same family. The only guidance is an auth prerequisite, which is not usage 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds a genuine behavioral trait beyond the annotations: results come from a cached exit node list, which tells the agent answers may be stale relative to live Tor consensus data.

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

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

Two short sentences, zero filler, and the purpose is front-loaded ahead of the caching caveat. Every sentence 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 one-parameter, read-only lookup with no output schema and clear annotations, the definition is nearly self-sufficient. The one minor gap is that it doesn't indicate the nature of the result (a boolean/verdict plus exit-node metadata), which the agent must infer.

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 one parameter and schema description coverage is 100% ('IP address to check', with ipv4/ipv6 formats), so the schema carries the full burden. The description adds nothing about accepted formats beyond what the schema already encodes, which is the baseline case.

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

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

States a specific verb ('Check') and resource ('a specific IP address is a known Tor exit node'), so the agent knows exactly what it does. It does not explicitly distinguish itself from siblings like tor_exit_nodes or tor_exit_details, though 'a specific IP address' implies single-IP lookup versus those list/detail tools.

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

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

Usage is implied by the phrasing 'check a specific IP', which contrasts with the list/detail siblings, but the description never states when to pick this tool over tor_exit_nodes or tor_exit_details, nor any prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the shape of the returned data (fingerprints, timestamps, exit addresses), which is useful, but says nothing about pagination behavior, result size, or data freshness beyond what the schema already implies.

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 filler; the returned-field list is the only elaboration and it earns its place given the absence of an output schema.

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

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

For a read-only, no-required-param lookup whose annotations carry the safety profile and whose single parameter is fully documented, the description is largely sufficient. The missing piece is differentiation from the other Tor-exit siblings, which leaves selection ambiguous.

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?

Only one parameter (limit) and schema coverage is 100%, so the schema fully documents it with default and bounds. The description adds nothing about the limit parameter, so the baseline 3 applies.

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

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

States a specific verb (Get) and resource (Tor exit node information) and enumerates the returned fields (fingerprints, publish timestamps, exit addresses). It does not, however, distinguish itself from the closely related siblings tor_exit_nodes and tor_exit_check, leaving the agent to guess which of the three Tor-exit tools to pick.

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, when not to, or which sibling is the alternative. With three Tor-exit-related tools in the list, the absence of any routing guidance is a real gap.

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 declare readOnlyHint=true and openWorldHint=true, so safety and external-list behavior are covered. The description adds that the source is the official Tor Project bulk exit list, which gives useful provenance context, but doesn't mention update frequency, format, or pagination behavior.

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

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

A single, tight sentence that front-loads the verb and resource with zero waste. Everything stated 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 simple read-only list tool with annotations and full schema coverage, this is adequate but minimal. It doesn't help the agent choose between this and the several related Tor siblings, which is the main contextual gap.

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

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

Schema coverage is 100% and the single optional limit parameter is well-documented in the schema. The description adds no additional parameter semantics, which is acceptable at this baseline.

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 (Get) and resource (list of Tor exit node IP addresses) with a clear source (official Tor Project bulk exit list). It distinguishes itself from the sibling tor_exit_check (which checks a specific IP) reasonably well, though it doesn't explicitly name that 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?

No guidance on when to use this versus tor_exit_check, tor_exit_details, or other Tor-related siblings. The agent must infer the difference between fetching a full list and checking/detailing a single node.

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

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

Annotations already declare readOnly/openWorld/non-destructive, so the safety profile is covered. The description adds genuinely useful non-obvious context: a Tor daemon must be running, DNS-leak prevention is handled via socks5h, and the return is raw HTML rather than parsed output.

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 short sentences, front-loaded with the action and resource, then preconditions, then constraints. Every sentence carries information; nothing is padded or redundant.

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, read-only fetch tool with no output schema, the description covers what it does, what it needs (daemon), what it accepts (.onion only), and what it returns (raw HTML). No significant gap remains for correct invocation.

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

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

Schema coverage is 100% and there is a single parameter, so the schema already documents the URL field and its http/https form. The description only reinforces the .onion restriction already implied by the schema, adding no format or validation detail beyond it.

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

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

States a specific verb and resource ('Fetch raw HTML from a .onion URL') plus the transport mechanism (Tor SOCKS5 proxy). Scope is narrow enough to distinguish it from siblings like tor_scrape_onion, tor_search_onion, and onion_lookup.

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

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

Gives concrete preconditions ('Requires a running Tor daemon') and a hard input constraint ('Only .onion URLs are allowed'), which is real usage guidance. It stops short of naming which sibling to use for scraping/searching onions, so routing among the tor_* family is left to inference.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false, openWorldHint=true), so the bar is lower, and the description still adds genuine operational context the annotations don't: the return payload shape (title, links, body text) and the prerequisite that a Tor daemon must be running. It stops short of failure modes, timeouts, or content/size limits for an outbound call to a hidden service.

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

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

Three short sentences, zero filler, and the primary purpose is front-loaded before the return shape and prerequisite. Every sentence 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 one-parameter read-only tool with full annotation coverage and no output schema, the description supplies both the prerequisite (Tor daemon) and the return contents, which is most of what an agent needs. Only error/timeout behavior and the routing versus tor_fetch_onion are missing.

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

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

Schema description coverage is 100% with a single required `url` parameter, so the schema already carries the semantics; baseline 3 applies. The description implies the URL must be a .onion address but adds no format, encoding, or length guidance beyond what the schema states.

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

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

States a specific verb+resource ("Fetch and parse a .onion site via Tor") and enumerates the returned fields, so the agent knows exactly what the tool produces. It fails to differentiate from the near-identical sibling tor_fetch_onion (and tor_search_onion), leaving the fetch-vs-scrape distinction 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?

No when-to-use guidance, no when-not-to-use, and no reference to any of the closely related siblings (tor_fetch_onion, tor_search_onion, onion_lookup). The only scoping information is the implicit ".onion" requirement in the URL parameter.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety and open-world profile is covered. The description adds useful context by disclosing the data source (Ahmia.fi) and, in the absence of an output schema, the return shape (titles, URLs, descriptions). It does not mention rate limits, result reliability, or coverage 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?

Two sentences, zero filler, with the core action front-loaded and the return values following. Every sentence 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 simple two-parameter search tool with full annotation coverage, the description is largely sufficient: it names the source, the action, and the return fields (compensating for the missing output schema). The main gap is the absence of any routing guidance relative to the several related onion/Tor siblings.

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

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

Schema description coverage is 100%, with both 'query' and 'limit' documented in the schema including the default of 20 and max of 1000. The description adds no semantics beyond the schema, so the baseline 3 is appropriate.

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

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

States a specific verb and resource ('Search for .onion sites') and names the underlying engine (Ahmia.fi), which helps distinguish it from siblings like onion_lookup or tor_scrape_onion. It is clear what the tool does, though it does not explicitly contrast itself with those closely related 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?

No statement of when to use this versus alternatives such as tor_fetch_onion, tor_scrape_onion, or onion_lookup. The agent is left to infer that this is a keyword search over hidden services, but there is no when-to-use or exclusion guidance.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds that it checks a local daemon and returns connectivity status, providing some useful context, but does not disclose return format, error behavior, or whether the check itself makes network requests.

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 primary function and followed by the return/purpose context. Every sentence earns its place with no redundancy.

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

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

Given the tool's low complexity, zero parameters, and rich annotations, the description sufficiently covers what it does and why it matters. The only minor gap is lack of detail on the return value format, which is acceptable without an output schema.

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

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

The tool takes zero parameters, so the baseline score of 4 applies. No parameter semantics are needed, and the description does not need to elaborate on inputs.

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