openosint

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

No annotations are provided, so the description bears full responsibility for behavioral transparency. It only states the generation function and does not disclose any behavioral traits such as whether it is read-only, requires authentication, or has rate limits. The description lacks sufficient detail for an agent to understand side effects or limitations.

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

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

The description is a single, well-structured sentence that is front-loaded with the key action and resource. Every word contributes meaning, with no redundancy or 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?

The description adequately explains what the tool does given its simplicity (2 params, no output schema). However, it does not describe the return format (e.g., list of URLs, JSON structure) or provide any context on how the URLs are generated. For a tool with no output schema, this omission leaves the agent partially uninformed.

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

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

The schema covers 50% of parameters (json_output has a description). The description adds significant value by clarifying the 'target' parameter, providing concrete examples ('name, email, username, domain') that are not in the schema. This helps the agent understand acceptable inputs beyond the raw type definition.

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

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

The description clearly states the action ('Generate') and the resource ('targeted Google dork URLs'), and specifies the types of targets it accepts ('name, email, username, domain'). This distinguishes it from sibling search tools that query databases rather than generate URLs.

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 implies this tool is used for generating dork URLs, distinct from the sibling search tools that perform actual searches. However, it does not explicitly state when to use this tool versus alternatives, nor does it provide any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It does this well by stating the graph is additive, the exact output format (NDJSON, one FtM entity per line), and that whole datasets can be omitted via exclude_datasets. It also warns about the installation requirement. It does not mention what happens when no data exists or whether output is streamed, but these are minor omissions for an export tool.

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

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

Two sentences carry all essential information: the action, the resource, the output format, the optional exclusion mechanism, and the installation prerequisite. It is front-loaded with the main purpose and contains no filler or redundant statements. 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 tool with two optional parameters and no output schema, the description provides a clear picture of what the tool emits and how to control dataset exclusion. The only notable gap is the interplay between json_output and the default NDJSON export: the schema says json_output returns structured JSON, but the description does not reconcile this with the NDJSON line-by-line format. Still, the agent can call the tool correctly with just this 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?

The input schema already covers both parameters with descriptions, so the baseline is 3. The description adds value by giving a concrete exclude_datasets example and clarifying that excluding a dataset removes 'every breach-derived fact'. It does not add much to json_output, but that parameter is already well described in the schema. Overall, the description meaningfully enriches the parameter 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 names a specific verb ('Export'), a specific resource ('the additive FollowTheMoney entity graph'), and the output format (newline-delimited JSON, .ftm-compatible). It clearly distinguishes itself from the sibling graph tools like graph_neighbors and graph_review_candidates, which are about querying or reviewing rather than exporting the whole graph.

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 explicit guidance on when to use this tool versus the graph_neighbors or search_* siblings. It does explain a prerequisite ('Requires the graph extra') and an optional exclusion pattern, but does not state when exporting is appropriate or when another tool would be a better fit. The usage context is only implied by the tool name and the export-focused wording.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses return contents, the optional cross-layer behavior, and the installation prerequisite. It does not discuss failure behavior, performance at max depth, or output format defaults, but the read-oriented nature of traversal is apparent from the wording.

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

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

Three sentences, each earning its place: one states the core action and output, one explains the optional cross-layer behavior, and one gives the installation prerequisite. Information is front-loaded and there is no redundant phrasing.

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

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

For a tool with no output schema and no annotations, the description is sufficiently complete: it states what is returned, the key optional behavior, and the required dependency. Missing details such as exact JSON shape or invalid entity handling are non-critical for invoking the tool correctly given the schema covers depth and output flags.

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 75%, so the baseline is 3. The description adds meaning for entity_id ("from one entity id") and enriches cross_layer ("surface bridge links into the raw infra correlation graph - IPs, domains, hashes"), going beyond the terse schema text. It appropriately does not need to restate depth or json_output since the schema already documents them.

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 uses a specific verb and resource: "Traverse the FollowTheMoney entity graph from one entity id out to a given depth," and states the output contents (entities, edges, per-edge provenance). It is clear and distinct from the sibling tools in focus, though it does not explicitly name a sibling alternative to distinguish against.

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 implies when to use the tool: when you need to traverse from a known entity id and see connected entities with provenance. It also gives context for setting cross_layer=true and mentions the 'graph' extra requirement, but it does not explicitly compare to alternatives like graph_export or investigate_multi or state when not to use it.

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

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

With no annotations, the description carries full burden and does so well: it reveals that reject permanently excludes future suggestions, that accept merges, that no auto-merge happens, and that this is the only write path for judgement='positive'. These are exactly the side effects an agent needs before calling.

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

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

The description is dense but every clause carries information: purpose, action modes, filters, verdict semantics, side effects, and authority. It front-loads the core purpose and uses punctuation to separate related facts without 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?

For a 10-parameter tool with no output schema or annotations, the description provides enough to invoke list or decide correctly and understand consequences. The main gap is that return values are not described beyond the candidate fields listed, though json_output hints at structured output.

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 80%, so the schema already handles most parameter meaning. The description adds value beyond schema by grouping parameters into list filters (schema, score range, dataset) and decide fields (pair, decision, reviewer), and by mapping decision values to judgement outcomes.

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

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

The opening sentence names a precise resource (human review queue for graph-dedup same_as matches) and the two actions it supports. This clearly distinguishes it from graph_export/graph_neighbors and the search_* siblings.

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

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

The description gives explicit conditions for each action: action='list' for pending candidates and filters, action='decide' for recording accept/reject verdicts. It does not name sibling alternatives that would cover the same job, hence 4 rather than 5.

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

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

Description mentions parallel execution, report generation, and an environment variable requirement. However, it lacks details on error handling, rate limits, report format, or potential side effects. With no annotations, the description carries the full burden but is adequate.

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

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

The description is very concise: three sentences covering purpose, outputs, constraints, and requirements. No unnecessary words 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?

Given the complexity (multiple targets, parallel, reports) and lack of output schema, the description covers key aspects: purpose, constraints, and env var. Minor gaps in report specifics and error handling prevent a perfect score.

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 description's parameter info ('List of OSINT targets (emails, usernames, domains, IPs). Max 10.') mostly echoes the schema. Therefore, the description adds minimal additional semantic value 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?

Description clearly states the tool investigates multiple targets in parallel using the full OSINT tool chain, producing individual and summary reports. This distinguishes it from sibling tools which are single-target searches.

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 implies use when investigating multiple targets simultaneously, and notes a maximum of 10 targets. It does not explicitly state when to use alternatives, but the context is clear given sibling tools are single-target.

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?

Discloses use of Web Unlocker API, bypasses Cloudflare/CAPTCHA, returns Markdown, and requires env vars. No annotations provided, so description carries burden; covers key aspects.

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

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

Two sentences, front-loaded with action, 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?

Covers core purpose and env vars, but lacks output structure details, error modes, or size limits. Sufficient for basic use.

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

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

Schema coverage is 50% (json_output described). Description adds that output is clean Markdown, but doesn't detail URL format or response structure. Adequate but not compensatory.

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 clearly states the tool fetches a public URL using Bright Data Web Unlocker API, bypassing protections, and returns Markdown. It distinguishes from sibling search 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?

Specifies required environment variables but lacks explicit when-to-use or when-not-to-use guidance compared to 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?

No annotations provided, but the description discloses key behaviors: it is a read operation, returns specific fields, shows a warning on high scores, and requires an API key. Lacks details on error handling or rate limits, but is adequate.

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

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

Two sentences, front-loaded with action, no redundant information. Every sentence serves a purpose.

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 tool with one required parameter and no output schema, the description covers return fields, prerequisites, and a special behavior. No gaps for this complexity level.

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

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

Schema coverage is 50% (json_output described). The description helps clarify the ip parameter by mentioning 'IP address', but does not add value beyond the schema for json_output. Partially compensates for missing schema descriptions.

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?

Description clearly states the tool checks an IP against the AbuseIPDB API for abuse reputation, specifying the API version and listing return fields. This distinguishes it from generic IP lookup tools among 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?

Description mentions the required environment variable and a warning threshold, but does not explicitly contrast this tool with sibling tools like search_ip, leaving usage context implied rather than explicit.

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

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

No annotations are present, so the description carries full disclosure burden. It fails to mention what happens on success/failure, rate limits, or return format, leaving significant behavioral gaps.

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 concise sentences, front-loaded with purpose, no superfluous words. Efficient and to the point.

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

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

No output schema is provided, so the description should explain return values, but it only says 'Check if an email appears.' External API context (rate limits, errors) 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 only 50%, with the json_output parameter described in schema but not elaborated in the description. The email parameter lacks schema description, and the description adds no extra meaning 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 clearly states the action ('Check') and resource ('an email appears in data breaches via HaveIBeenPwned'). It effectively distinguishes from sibling search tools by specifying the HIBP service.

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?

Only mentions the required HIBP_API_KEY env var, but does not provide guidance on when to use this tool versus alternatives, nor any context about when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It states what data is returned for IP and domain, and that env vars are required, but lacks details on rate limits, pagination, error handling, or whether the operation is read-only. The description adds value but is not fully transparent.

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

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

The description is two sentences, front-loaded with the main purpose and followed by specific output details and a prerequisite. Every sentence is informative without 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?

Given the tool has only 2 parameters and no output schema, the description adequately covers the main purpose and return values for typical inputs. It mentions required env vars, which is crucial context. However, it could be slightly more complete by hinting at the default output format (JSON or text) when json_output is not used.

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

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

Schema description coverage is 50% (only json_output has a description). The description adds context for 'target' by explaining IP→... and Domain→... outputs, but does not specify input format (e.g., IPv4, hostname). It partially compensates for the missing schema descriptions but not completely.

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 clearly states the tool searches Censys for internet-facing infrastructure data, specifying concrete outputs for IP (open ports, services, ASN, country) and domain (certificate history, SANs, etc.). It distinguishes from sibling tools like search_ip or search_shodan by being Censys-specific and listing unique return data.

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 mentions required environment variables (CENSYS_API_ID, CENSYS_SECRET) but does not provide explicit guidance on when to use this tool versus alternatives like search_shodan. Usage context is implied but not clearly delineated.

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

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

With no annotations, the description carries the full burden. It discloses that the tool performs live DNS queries without requiring external APIs or credentials, which implies read-only behavior. However, it does not mention potential limitations like rate limiting, caching, or query timeout. The explanation of email security misconfigurations adds useful behavioral 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 concise sentences, front-loaded with the primary action and record types, followed by additional valuable information (email security and credentials). No superfluous words; 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?

Given the tool's simplicity (2 params, no output schema, no annotations), the description covers the purpose, scope, and a key constraint (no credentials). It could mention the response format or potential delays, but overall it provides adequate context for an agent to understand the tool's capabilities.

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

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

Schema coverage is 50%: only 'json_output' has a description. The description adds overall context but does not directly explain the 'domain' parameter beyond what is implied. For 'json_output', the schema already provides meaning. The description's mention of DNS enumeration indirectly covers the domain parameter, but it does not add explicit parameter-level detail. Baseline is 3 due to moderate schema coverage combined with some contextual support.

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?

Description clearly states it performs comprehensive DNS record enumeration and lists specific record types (A, AAAA, MX, NS, TXT, CNAME, SOA). It also highlights additional email security checks, making the purpose very specific and distinguishable from sibling tools that deal with other data sources.

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 indicates that no external API or credentials are required, which is a clear usage guideline. However, it does not explicitly state when to use this tool versus alternatives like 'search_censys' or 'search_shodan', though the context implies it's for DNS enumeration. A slight lack of exclusion criteria prevents a perfect score.

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

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

No annotations provided; description merely states the action without disclosing behavioral traits such as rate limits, result format, or side effects. The mention of sublist3r hints at external dependency but insufficient 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?

Single concise sentence, front-loaded with action, no unnecessary 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?

No output schema, no annotations, and description does not cover result format, error conditions, or scope of enumeration. Leaves significant gaps for an agent.

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 has 50% coverage (json_output described). Description adds 'using sublist3r' but does not clarify the domain parameter's format or constraints. No value beyond schema for the domain parameter.

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?

Description clearly states verb 'enumerate', resource 'subdomains of a target domain', and tool 'sublist3r'. Distinct from sibling tools like search_dns or search_breach.

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 tool versus alternatives like search_dns or search_censys. Implicit usage but lacks explicit context 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?

With no annotations provided, the description fully carries the burden of disclosure. It explicitly states tool uses Bright Data SERP API, requires env vars (BRIGHTDATA_API_KEY and BRIGHTDATA_SERP_ZONE), and each dork incurs a cost. It also specifies the return format (title, URL, snippet). No contradictions.

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

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

Two sentences, front-loaded with core purpose, no filler. Every sentence adds value: action, data source, result, default limit, billing, env vars.

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 tool with two parameters and no output schema, the description covers purpose, behavior, requirements, and billing. It lacks details on error handling or edge cases, but is sufficient for an agent to make a decision.

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

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

Schema description coverage is 50% (json_output has description, target does not). The tool description adds context that 'target' is the subject of dork queries and that results are structured, but does not elaborate on target format or constraints. Adequate but not exceptional.

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?

Description clearly states the tool executes Google dork queries for a target via Bright Data SERP API, returning live structured results. This distinguishes it from sibling tools like 'generate_dorks' which likely only generates queries, and 'investigate_multi' which is a broader investigation.

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 mentions a default of up to 5 dorks and that each is a billable API call, providing practical usage guidance. However, it does not explicitly state when to use this tool versus alternatives, though the implication is clear for live execution.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It only says 'enumerate' without explaining whether the tool is read-only, requires permissions, has rate limits, or potentially sends network requests (holehe is a passive enumeration tool but could be interpreted as active).

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

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

The description is a single, front-loaded sentence with no unnecessary words. It is appropriately concise for a simple tool, though additional context could be added without harming conciseness.

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

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

Given the tool has two parameters and no output schema, the description is incomplete. It does not explain the return format (beyond the json_output flag) or typical response structure (list of accounts, links, or errors). For a simple enumeration tool, more context is needed for correct invocation.

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

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

Schema description coverage is 50%: json_output has a description, but email does not. The description mentions email in context but does not add format or validation details. The missing email description is partially compensated by the tool's name and context, so score is at 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?

The description clearly states the tool enumerates accounts linked to an email using holehe, with a specific verb and resource. It distinguishes from sibling tools that search by different identifiers (domain, username, IP, etc.), but could be more precise about what 'accounts' means (e.g., social media profiles).

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 tool versus alternatives like search_breach or search_username. There are no explicit when-to-use or when-not-to-use conditions, nor are alternative tools mentioned for comparison.

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?

Describes the process (detects entity type, runs queries, returns structured results and graph nodes/edges) and notes billable queries. Without annotations, some behavioral aspects (side effects, error states) are missing.

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, first front-loads action and mechanism, second details outputs and prerequisites. No redundant 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?

Covers key aspects: purpose, mechanism, prerequisites, and output types. Lacks details on error handling and rate limits, but sufficient for a search tool with 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?

Description adds context that queries are billable and target is an entity. With 67% schema coverage, it partially compensates but does not fully define all parameter behaviors beyond 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?

Clearly states it collects a target's public search-engine footprint via Bright Data SERP API, detects entity type, and runs entity-type-aware queries. Distinguishes from siblings that focus on specific data sources.

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?

Implies usage for footprint collection but lacks explicit when-to-use or when-not-to-use guidance. Does not mention alternatives among siblings, though prerequisites (env vars) are stated.

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

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

Since no annotations are provided, the description carries full burden. It discloses rate limit differences and response variations based on query type. It doesn't explicitly state safety (read-only), but search is inherently non-destructive.

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

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

Three sentences front-load the main purpose and provide essential details without fluff. Every sentence adds distinct value: purpose, behavior details, and rate limit info.

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

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

The description covers main aspects: query types, response content, rate limit. It lacks explicit mention of default output format (likely text vs JSON). Given no output schema, this is a minor gap but overall sufficient for the tool's complexity.

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

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

Schema description coverage is 50% with only json_output described. The description adds meaning for the query parameter by explaining its purpose and behavior logic. This compensates for the undocumented query parameter in 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 clearly states the tool searches GitHub for a username, email, or keyword. It distinguishes from sibling tools by naming the platform and specifying behavior differences for exact vs non-exact queries.

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 provides context on behavior (exact match returns full profile, other queries top 5) and rate limit with GITHUB_TOKEN. It doesn't explicitly state when to use or alternatives among siblings, but the specificity to GitHub implies usage context.

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

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

With no annotations, the description should fully disclose behavioral traits. It mentions the data source but does not discuss rate limits, authentication requirements, or whether the operation is read-only.

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

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

The description is a single, efficient sentence that immediately conveys the tool's purpose. Every word 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?

Given no output schema, the description could hint at the structure of the returned data. It mentions geolocation and ASN but doesn't outline fields, which would help an agent parse results.

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

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

Schema coverage is 50% (only json_output has a description). The tool description adds no extra meaning for the 'ip' parameter, leaving its expected format (IPv4/IPv6) unspecified.

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

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

The description explicitly states the action (retrieve) and the resource (geolocation and ASN data for an IP address), and distinguishes from sibling tools by specifying the data source (ipinfo.io).

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 is provided on when to use this tool versus alternatives like search_ip2location or search_shodan, nor any context on prerequisites or limitations.

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

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

No annotations provided. Description explains what it returns and that it requires an API key. Lacks details on rate limits, error handling, or what happens if key is missing.

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

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

Three sentences front-loaded with purpose, no filler. Efficient and to the point.

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

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

No output schema, but description lists many returned data points (geolocation, ISP, etc.). Sufficient for a simple lookup tool, though missing details on error responses.

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

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

Schema coverage is 50% (only json_output has description). Ip parameter lacks description; description does not clarify expected format (IPv4/IPv6). The description adds value by listing output fields but does not compensate for missing ip documentation.

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

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

Description clearly states it returns geolocation, ISP, ASN, and detects VPN, proxy, Tor, datacenter hosting, distinguishing it from basic IP tools like search_ip. It also notes it's a sponsored integration.

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?

Mentions required environment variable, implying prerequisite. Does not explicitly state when to use vs alternatives, but 'Enhanced' suggests it's for more detailed intelligence. Sibling names provide context.

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

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

With no annotations, the description carries full burden but only mentions the source (psbdmp.ws), not rate limits, auth, or result behavior; minimal 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?

Single sentence, no fluff, but slightly under-specified; appropriate length but could be more structured.

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

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

Does not explain output, json_output effect, or differentiate usage from siblings; incomplete for a simple tool with 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?

Schema coverage is 50%, and description adds no extra meaning beyond the schema; does not explain query format or json_output behavior to compensate.

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 clearly states it searches Pastebin dumps for an email or username via psbdmp.ws, specifying the verb, resource, and source, distinguishing it from siblings like search_email and search_username.

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 tool versus alternatives like search_email or search_username; lacks context for usage decisions.

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

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

No annotations are provided, so the description fully carries the burden. It mentions 'gather carrier and geolocation data' but does not disclose side effects, authentication needs, rate limits, or failure modes. Minimal behavioral insight.

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 redundancy. The purpose is front-loaded, and the format instruction is directly useful. Every word earns its place.

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

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

No output schema or annotations exist. The description lacks details on return format (beyond 'geolocation data'), error handling, or limitations. Not sufficiently complete for a data-gathering tool with two parameters.

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

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

The description adds the essential E.164 format requirement for the 'phone' parameter, which is not in the schema. The json_output parameter's schema description is clear but not enhanced. With 50% schema coverage, the description compensates well.

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 clearly states the tool gathers carrier and geolocation data for a phone number using phoneinfoga, and the E.164 format requirement. It is specific to phone numbers, distinguishing it from sibling search 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?

The description instructs using E.164 format, but provides no guidance on when to use this tool vs alternatives (e.g., for email or domain searches). No when-not or context 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?

No annotations provided, so description carries full burden. It discloses behavioral difference based on query type and authentication requirement. However, it omits details like rate limits, error handling, or pagination, making it adequate but not comprehensive.

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 efficient sentences with no filler. First sentence states overall purpose, second provides query-specific guidance and a prerequisite. Every word adds value.

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

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

Given no output schema and sibling tools, description sufficiently covers what the tool does and how to use it. It explains query types and output option, though return format details (e.g., host info vs banners) are not explicitly described, leaving minor gaps.

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

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

Description adds meaning beyond schema: explains that 'query' behaves differently for IP vs other strings. Schema only describes 'json_output' briefly; description adds no additional detail there but compensates for the 50% coverage by contextualizing the main parameter.

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?

Description clearly states the tool queries Shodan for host intelligence or banner search, and distinguishes between IP address and other strings. This differentiates it from siblings like search_censys and search_ip.

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 provides explicit context: use IP for host lookup, any other string for keyword/service search. It also mentions the required SHODAN_API_KEY env var. Does not explicitly exclude alternatives but is clear enough.

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

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

No annotations are provided, so the description carries full burden. It mentions 'using sherlock' but does not disclose behavioral traits such as network usage, rate limits, accuracy, speed, or any side effects. The verb 'enumerate' implies an interactive process, but details are missing.

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

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

The description is a single concise sentence that immediately states the core purpose. It is front-loaded and contains no unnecessary 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?

For a tool with no output schema and only two parameters, the description is too sparse. It does not explain what the output looks like, how to interpret results, or any operational details (e.g., network requirements). Given sibling tools, more context would help differentiate use cases.

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

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

Schema description coverage is 50% (only json_output has a description). The description does not add meaning for the username parameter, and does not clarify the format or constraints beyond what the schema provides. This is inadequate given the low coverage.

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

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

The description clearly states the tool enumerates platforms where a username is registered using sherlock. It specifies a specific verb (enumerate) and resource (platforms for a username), and it distinguishes from sibling tools that focus on emails, domains, IPs, etc.

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 is provided on when to use this tool versus alternatives, nor are there any exclusions or context about prerequisites. The description simply states what it does without helping the agent decide when it 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?

With no annotations, the description carries the full burden. It discloses key behaviors: auto-detection of input type and dependency on VIRUSTOTAL_API_KEY. This adds significant value beyond what the schema provides.

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

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

The description is two sentences, each serving a purpose: stating function and listing dependencies. No redundant information; it is front-loaded and efficient.

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

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

The description lacks details on return format (except for json_output option), error handling, or pagination. Given the tool has no output schema and the service provides rich data, more context on expected output would improve completeness.

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

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

Schema description coverage is 50% (only json_output is described). The description compensates by listing supported input types (IP, domain, URL, file hash) and explaining auto-detection, which clarifies the 'target' parameter's purpose and accepted values.

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 explicitly states the tool checks IP, domain, URL, or file hash against VirusTotal's 70+ engines. It distinguishes itself from siblings by supporting multiple input types with auto-detection, unlike sibling tools that handle single types.

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 mentions auto-detection and the required API key, providing some usage context. However, it does not explicitly state when to use this tool versus sibling tools like search_ip or search_domain, nor does it give conditions to avoid using it.

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

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

No annotations are present, so the description must disclose behavioral traits. It only describes the action without mentioning rate limits, data availability, read-only nature, or potential redactions (e.g., GDPR). This is insufficient for informed invocation.

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

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

The description is a single, efficient sentence that communicates the core purpose without redundancy. It is appropriately sized, though it could benefit from additional context without becoming verbose.

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

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

Given the absence of annotations and output schema, the description is too minimal. It fails to explain what data is returned (e.g., registrar, dates, contacts) or any constraints like domain format. This leaves the agent with insufficient information to handle results properly.

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

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

Schema description coverage is 50%, but the tool description adds no extra meaning to either parameter. The 'domain' parameter lacks explanation, and 'json_output' is only partially covered by the schema. The description does not compensate for low coverage.

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

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

The description explicitly states the verb 'retrieve' and the resource 'WHOIS registration data' for a domain, which clearly distinguishes it from sibling tools like search_dns or search_domain. It leaves no ambiguity about what the tool 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?

No guidance is provided on when to use this tool versus alternatives like search_domain. There is no mention of prerequisites or context for appropriate use, leaving the agent without decision support.

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