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

With no annotations, the description fully explains the risk flag criteria (CRITICAL, HIGH, WARN), sorting by commitment score, and batch size constraints (up to 20 packages). It lacks explicit read-only safety confirmation but is otherwise 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 well-structured with a summary, risk definitions, and examples. It is concise and front-loaded, though slightly verbose in the examples section.

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), the description fully explains input, output format, risk logic, and usage scenarios. No gaps remain.

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 adds no new parameter semantics beyond what the schema provides, but the schema is clear.

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 specifies the verb 'batch-score', the resource 'multiple npm or PyPI packages', and the outcome 'supply chain risk' with a risk table. It clearly distinguishes from sibling tools that perform single-package 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?

The description provides explicit use cases like auditing package.json or requirements.txt, and examples of applications. However, it does not explicitly state when not to use this tool, though the batch nature implies 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 full burden. It explains the data source (Brreg) and the categories of commitment signals, but lacks details on edge cases (e.g., business not found, rate limits, required permissions).

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 paragraph with front-loaded purpose. It is concise but includes some marketing language ('can't be faked') that slightly reduces efficiency. Overall, it is well-structured for quick scanning.

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

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

No output schema exists, so the description must explain return values. It lists the commitment categories, which is helpful, but omits details on output format, error handling, pagination, and data freshness. It is moderately complete but not fully sufficient for all agent needs.

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% with clear parameter descriptions. The description does not add substantial semantic value beyond the schema; it mentions the query parameter implicitly but does not enrich the meaning of 'maxResults' or provide additional constraints.

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

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

The description clearly states the tool searches for a Norwegian business and returns its commitment profile from public data. It specifies the verb 'search' and the resource 'Norwegian business', but does not explicitly distinguish from the sibling tool 'lookup_business_by_org'.

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 usage for verifying Norwegian businesses via government registers and lists the return data. However, it does not provide explicit guidance on when to use this tool versus alternatives like 'lookup_business_by_org' or 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 explicitly states the tool performs a lookup from public data (Brønnøysund Register Centre), implying read-only and non-destructive behavior. This is sufficient for transparency, though it does not detail any caveats like rate limits or data freshness.

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 sentence that efficiently conveys purpose, input, and output. It is front-loaded and contains no redundant information, earning its place. However, it could be slightly more structured (e.g., separate sentence for output details).

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 lookup tool with one parameter and no output schema, the description adequately explains the input and the expected return values (four signals). It is complete enough for an agent to understand what results to expect, though adding a brief note on the format of the returned data 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?

The schema covers 100% of parameters (orgNumber) with description. The tool description adds context about what the parameter is used for (Norwegian organization number) and example format, but essentially repeats schema info. Baseline 3 is appropriate as schema already 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 clearly states the action (lookup), the resource (Norwegian business by organization number), and the output (commitment profile with specific signals: longevity, financial health, operational activity, overall commitment score). It distinguishes itself from sibling tools like lookup_github_repo or lookup_npm_package by focusing on Norwegian businesses.

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 this tool (when needing commitment profile for a Norwegian business), but it does not explicitly state when not to use it or provide direct comparison to sibling tools such as lookup_business or query_commitment. Usage context is clear but lacks explicit alternatives 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?

No annotations are provided, so the description carries full burden. It states the tool is read-only ('Get' and 'Returns'), works only with public repos, and describes the nature of the returned signals (behavioral commitments). It does not mention rate limits or authentication, but the read-only nature is clear.

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 well-structured with a first paragraph explaining functionality and a second paragraph for use cases and examples. It is concise without redundant words, but could be slightly tighter.

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

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

Given the low complexity (one parameter, no nested objects), the description fully covers what the tool does, what it returns, and when to use it. No output schema is present, but the listed signals provide adequate expectations.

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% with the 'repo' parameter's description already explaining the format and providing an example. The tool description repeats the example without adding new meaning beyond the schema, so baseline of 3 is appropriate.

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

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

The description clearly states it gets a 'behavioral commitment profile' for any public GitHub repository and lists the returned signals. It distinguishes itself from sibling tools which cover different domains (business, npm, Go modules, 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?

The description explicitly lists use cases: 'vetting open-source dependencies, evaluating AI tools/frameworks, assessing vendor reliability.' It provides examples but does not specify when not to use or mention alternatives. Since siblings cover other package types, the context 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?

With no annotations, the description fully discloses behavior: input constraints, return signals, and ecosystem nuances (no download counter, GitHub-primary). 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?

Well-structured with separate paragraphs for output, ecosystem notes, and usage; not overly verbose. A bit lengthy but justified by the need to explain Go ecosystem specifics.

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?

Despite lacking output schema, the description enumerates all returned signals and addresses potential ambiguities (e.g., publisher vs contributor). The single parameter is fully documented.

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 covers 100% of the single parameter, and the description adds value with examples, case-sensitivity mention, and context about module paths. Exceeds 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?

The description clearly states it obtains a 'behavioral commitment profile' for a Go module, listing specific signals (age, versions, etc.). It distinguishes from sibling tools which target different ecosystems or actions.

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

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

Explicit usage scenarios are given ('vetting Go dependencies, abandonware identification, supply chain risk') with concrete examples. Lacks exclusion criteria but is sufficient for correct invocation.

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 burden. It discloses the nature of the tool (read-only, returns signals) and mentions supply chain attack relevance, publisher depth, and behavioral signals. It does not describe rate limits or API dependencies, but for a simple lookup tool, the transparency is sufficient.

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 concise: 4 sentences plus bullet-point use cases and examples. It front-loads the purpose, details outputs, then provides context and examples. Every sentence is informative and 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 one parameter and no output schema, the description explains the return values (signals list) and usage scenarios. It covers input semantics well, though lacks potential notes on data freshness or API limitations. Overall, it is adequately complete for a straightforward tool.

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

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

The single parameter 'package' has a schema description covering 100%. The description adds value by specifying scoped packages need '@' prefix and giving examples, which aids correct input. This exceeds the baseline of 3 for full schema coverage.

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

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

The description clearly identifies the tool as retrieving a 'behavioral commitment profile' for npm packages, listing specific signals (package age, download volume, trend, etc.). It distinguishes from siblings like lookup_pypi_package and lookup_github_repo by focusing on npm packages, making the purpose precise and 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?

The description explicitly states use cases ('vetting dependencies, identifying abandonware, due diligence') and provides examples. It does not mention when not to use it or name alternative tools, but the context signals and sibling list imply differentiation. The guidance is strong but lacks explicit 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 carries the full burden. It does disclose the return content (signals) and implies a read-only lookup, but it does not mention rate limits, authentication, errors, or side effects. The supply-chain anecdote adds context but isn't a behavioral disclosure, so the transparency is adequate but not detailed.

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

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

The description is front-loaded with purpose, but the second paragraph about the LiteLLM incident is somewhat tangential to tool selection or invocation. It adds context but is not essential and could become stale. The structure is clear, but the length could be reduced without losing core guidance.

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 single-parameter lookup tool, the description covers the essential context: what it does, what data it returns, and when to use it. The absence of an output schema is mitigated by the description listing the returned signals. It doesn't explain auth or pagination, but these are less critical for a straightforward package 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 coverage is 100% and the schema already describes the 'package' parameter with examples and case-insensitivity. The description reinforces this by listing example package names, but adds no new parameter-level semantics beyond what the schema provides. Baseline 3 applies because the schema carries the load.

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

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

The description opens with a clear, specific verb+resource combination: 'Get a behavioral commitment profile for any PyPI (Python) package.' It lists exactly what signals are returned (age, downloads, release consistency, etc.), and the PyPI scope differentiates it from sibling tools like lookup_npm_package or lookup_go_module.

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 use cases: 'vetting Python dependencies, identifying abandonware, supply chain risk due diligence.' The package name examples further clarify when to use this tool. However, it doesn't explicitly mention when not to use it (e.g., if you need an audit or GitHub-specific analysis), so it lacks exclusion statements.

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?

There are no annotations, so the description carries the full burden. It discloses that the data is 'verified' and returns 'aggregated signals,' which adds meaningful context beyond a simple read operation. However, it does not mention operational details such as whether the data is cached, potential rate limits, or errors on unknown domains. Some context is provided, but not exhaustive.

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 three sentences: the first states the action, the second lists the return values, and the third explains its value proposition. Every sentence earns its place without redundancy. It is front-loaded with the core purpose and remains concise.

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 tool is simple with one parameter and no output schema. The description sufficiently explains what the tool returns and why it is useful, covering the return values in enough detail. However, because there is no output schema, it could benefit from a brief note on output format or error behavior, which is a minor 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?

With 100% schema coverage, the input schema already documents the 'domain' parameter thoroughly, including normalization. The description adds no extra meaning about parameters, so the baseline of 3 applies. It neither enhances nor detracts from the schema's clarity.

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's function: 'Query verified behavioral commitment data for a domain.' It lists specific outputs (unique verified visitors, repeat visit rate, average time spent), which distinguishes it from sibling lookup tools that focus on business, packages, or repositories. The verb and resource are specific, making its purpose 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?

The description provides clear context for when to use this tool: when you need to prove real human engagement, as it says the data is 'harder to fake than reviews or content.' However, it does not explicitly state exclusions or compare directly to alternatives like 'use this instead of lookup_business.' Thus it has clear context but lacks explicit when-not guidance.

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