Ansvar: EU Compliance & Legal Intelligence

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 clear. The description adds the behavioral constraint of max 100 and 'one query', but does not disclose return format, error handling, or partial failure 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?

The description is two sentences with no wasted words. It front-loads the action and includes a concise usage tip. 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?

For a simple, read-only batch tool, the description covers the basic purpose and limit, and annotations cover safety. However, without an output schema, it does not specify what 'details' includes (e.g., which fields beyond KEV/EPSS) or behavior for invalid CVE IDs, leaving some gaps.

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

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

Schema description coverage is 100%, with all three parameters documented (cve_ids, include_kev, include_epss). The description adds no additional parameter meaning beyond framing the batch nature, so it meets the baseline of 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 verb ('Get details'), resource ('multiple CVEs'), and scope ('in one query (max 100)'). It distinguishes itself from sibling tools like get_cve_details by emphasizing batch capability, making the purpose immediately clear.

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

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

The phrase 'Efficient for bulk vulnerability assessment' provides clear context for when to use this tool. However, it does not explicitly mention alternatives or when-not-to-use scenarios, such as pointing to get_cve_details for single CVE 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 only mark readOnlyHint=false and destructiveHint=false, but the description adds crucial behavioral details: idempotency ('returns the same result'), irreversibility ('cannot be resumed'), and persistence ('record stays visible in list_workflows'). It also explains the impact on resume_workflow's active listing, which annotations cannot convey.

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 core action, then condenses essential caveats (idempotency, resume exclusion, listing visibility) into a compact, well-structured format. Every sentence 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?

For a simple single-parameter cancellation tool with an output schema, the description covers the core operation, irreversible side effects, idempotency, and the relationship to sibling tools (resume_workflow, list_workflows). It is complete enough for an agent to invoke safely and correctly.

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

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

The input schema has 100% parameter description coverage, including how to obtain workflow_id and how to recover a lost id. The description adds no additional parameter semantics beyond what the schema already provides, so the baseline score 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 opens with 'Cancel an active workflow by id', a specific verb+resource combination. It distinguishes itself from resume_workflow by noting cancelled workflows cannot be resumed and are excluded from its active listing.

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 clearly states when to use the tool (to stop an active workflow) and implicitly warns against use if resumption may be needed ('cannot be resumed'). However, it does not explicitly name alternative tools or provide a when-not-to-use list beyond the resumption caveat.

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. The description adds behavioral context by specifying the return value includes KEV details, remediation actions, and due dates, which goes beyond the annotations.

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

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

The description is two sentences: the first states the main purpose, the second lists the key return fields. Every word earns its place, with no redundancy or unnecessary 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 simple one-parameter read-only tool with no output schema, the description is complete. It explains what the tool does and what it returns, making it sufficient for an agent to select and 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 description coverage is 100%, with the required cve_id parameter described as 'CVE identifier'. The description reinforces the parameter's purpose but adds no additional semantic detail beyond what the schema 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?

The description clearly states the tool checks if a CVE is in the CISA KEV catalog, using a specific verb and resource. It distinguishes itself from siblings like get_cve_details and search_cve by focusing on KEV-specific 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?

The description provides clear context for when to use the tool (whenever KEV status is needed) but does not explicitly mention alternatives or exclusions. The narrow scope makes the usage obvious, so it earns a 4 rather than a 3.

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?

Adds useful behavioral details beyond annotations: returns {mermaid, validation_errors, structural_warnings}, 'Bad input returns validation_errors with mermaid=null; it never raises', and lists validation checks. It does not disclose side effects despite readOnlyHint=false, but no direct contradiction arises.

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 long but dense, covering purpose, workflow, input structure, and error handling in a structured way. It front-loads the core action and uses the rest for necessary detail, so it is efficient despite length.

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 complex tool with nested objects, the description covers workflow context, input schema details, return values, and error behavior. It leaves no significant gaps for an agent to select and invoke the tool 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 the description mirrors the schema's artifact structure almost exactly. It adds no new parameter semantics beyond what the schema already provides, 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?

The description opens with 'Validate a DFD artifact and render it as styled Mermaid,' which is a specific verb+resource. It clearly distinguishes itself from siblings by referencing the DFD specialist workflow and submit_response, positioning it as the validation/rendering step.

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

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

Explicitly states when to use: 'after the DFD specialist has finished extraction' and 'before the artifact is submitted via submit_response'. This gives clear workflow context. However, it does not name alternative tools or explicitly state when not to use it, so it falls short of a 5.

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

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

Despite annotations already indicating read-only and non-destructive, the description adds substantial behavioral context: validation order (detail before section), error handling for unknown sections, tier-aware filtering, TTL-cached workflow registry reconciliation, service notices, and catalog drift. This goes well beyond the annotations and clarifies exactly what the tool returns and how it behaves.

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 long but densely packed with valuable information, and the main purpose is front-loaded. It could be more structured with bullets or shorter sentences, but every sentence contributes and there is no redundancy. Slightly heavy but justified by the tool's complexity.

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

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

With an output schema present, the description doesn't need to explain return schemas, but it covers errors, edge cases, data source, refresh behavior, tier-awareness, and companion tools. This is complete for a tool of this complexity and optionality.

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%, but the description still adds enormous value by explaining what each detail value returns, how sections work, and the precedence of validation. It clarifies the 'full' mode is over 100k chars and that unknown sections return errors with valid ids. This meaningfully complements 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 that this tool discovers what Ansvar can do for an agent, using a specific verb+resource. It explicitly contrasts itself with the sibling get_my_capabilities (live tier/quota only), distinguishing its role as the catalog/capability discovery tool.

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

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

The description explicitly names the alternative get_my_capabilities and notes it is for live tier/quota only, while describe_capabilities is the companion for discovering capabilities. It also provides clear guidance on how to use detail and section modes, including error conditions.

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

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

Annotations only declare readOnlyHint=true and destructiveHint=false. The description adds substantial behavioral context: it returns a structured diff with added, removed, and modified text, and it specifies detailed rendering rules for the 'Sources used' table, including curation criteria and completeness-loss labeling. This far exceeds the baseline and gives the agent clear expectations for the response format.

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 a clear purpose sentence and usage examples, which is good. However, the long block of source-rendering rules (I1–I5) adds significant length and complexity. While each rule is actionable, the description could be more concise by moving some of that detail to a separate output specification, reducing cognitive load for the agent.

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 has no output schema, so the description must explain return values. It does mention the structured diff content (added/removed/modified) and the mandatory Sources table, covering essential aspects. However, it does not describe the exact structure or format of the diff beyond that, which would be helpful. Given the parameters are fully documented and the tool is read-only, the description is sufficiently complete for safe invocation.

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

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

Schema description coverage is 100%, with each of the five parameters well-defined in the input schema. The description does not add extra parameter semantics beyond what the schema already documents, so the baseline of 3 applies. It correctly implies date-window semantics via the example queries but does not elaborate further.

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 specific verb and resource: 'Compare two versions of a legal provision to see what changed.' This clearly distinguishes the tool from siblings like get_provision or get_changes by focusing on the diff between versions. The examples further reinforce the exact scope (e.g., DORA amendments, GDPR article changes).

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 guidance is provided with 'Use this when someone asks...' followed by concrete query examples: 'what changed in the latest DORA amendment', 'how did this article change between versions', 'show me the differences in GDPR Article 17 after the update'. This tells the agent exactly when to select this tool over 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?

The description goes far beyond the readOnlyHint/destructiveHint annotations. It discloses refusal behavior with failure feedback, render failure handling ('attach render_error and never drop the report JSON'), tier-based restrictions, watermark behavior on free/solo, and the policy of refusing unsupported formats instead of quietly downgrading. This is rich behavioral context that the annotations alone do not provide.

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

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

The description is front-loaded with the core purpose, then usage triggers, then behavioral details, each sentence earning its place. Despite its length, it is dense with actionable information and has no filler or 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?

The description covers the return format ('structured report with findings, citations, and recommendations'), failure modes, tier-specific behavior, error keys, and even the fact that render failures never drop the JSON. With an output schema present and full parameter coverage, this description is complete 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?

The input schema already provides 100% coverage for both parameters, so the baseline is 3. The description adds meaningful behavior around the format parameter: 'branded rendered artifacts as short-lived download URLs', 'sibling render key', and explicit tier consequences. However, there is a slight inconsistency between the schema enum (json/html/pdf) and the description's mention of docx/all, which creates minor ambiguity even though the schema's own description also lists those values. Hence 4 rather than 5.

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 specific verb and resource: 'Produce the final compliance report from a completed workflow.' It also provides concrete trigger phrases ('generate the gap analysis report', 'I need the DPIA report as a document') that distinguish it from sibling tools like start_workflow or get_workflow_threats. This is a clear, differentiated statement of purpose.

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

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

Explicit when-to-use guidance is given via example user requests. It also states preconditions ('from a completed workflow', 'Refuses until every quality gate passes') and an explicit when-not: formats the caller's tier does not serve are refused rather than downgraded. This fully meets the 5-level criteria of explicit when/when-not and 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, destructiveHint=false, openWorldHint=false, and the description adds substantial behavior: the EU Regulations baseline-only restriction, default since, empty-response semantics, capability-miss responses, legacy event_kind unknown, and strict scope refusal. It also details response formatting rules (Sources used table curation) that go well beyond the annotations.

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

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

Though long, the description is front-loaded with the core purpose, then systematically covers defaults, boundary conditions, error behavior, and response rendering rules. Every sentence provides distinct information (e.g., rendering rules I1-I5) that an agent needs. It is dense but not redundant with the annotations 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?

Given 7 parameters, no output schema, and complex behavior, the description is remarkably complete. It explains what the tool does, when to use alternatives, how scopes are validated, what responses look like on misses, and how to render the 'Sources used' table. There is no obvious missing context for an agent to invoke and interpret this tool 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 baseline is 3. The description adds meaning to parameters by explaining that scopes (sources, frameworks, jurisdictions) are only dispatched if amendment-capable, and that the EU Regulations source is baseline-only (excluded from amendment-capable dispatch). It also clarifies invalid scope behavior, which gives deeper context than the schema alone, so a 4 is warranted.

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 starts with a specific verb and resource: 'Find observed rows from legislative change feeds in a jurisdiction or framework, or from an explicit source.' It clearly distinguishes itself from siblings by naming the boundary with search_regulatory_updates ('amendments observed in SERVED corpus text') and pointing to diff for a known provision.

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 guidance is provided: use for 'what laws changed in Sweden this month' only when scope is amendment-capable, and explicit alternatives are given ('Use diff for a known provision', 'use search_regulatory_updates' for newly published acts). It also clarifies when not to use and includes default behavior (since defaults to last 90 days).

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?

Beyond the read-only annotation, the description discloses key nuances: questions_for_user is advisory while requires_user_input is server-enforced, and it explains user_provided_fields gating submit_response. This adds significant operational context not available from annotations alone.

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: the main purpose, usage examples, and important field semantics. It is dense with useful information and contains no redundant phrases.

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

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

With an output schema present, the description doesn't need to enumerate return fields, but it explains their behavior (advisory vs. enforced, user_provided_fields). This covers the core functionality and edge-case semantics, making it complete for an agent to use correctly.

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

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

The input schema already fully documents workflow_id, including its origin from start_workflow and recovery via list_workflows (100% coverage). The description does not add further parameter semantics, so the baseline score 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 the tool checks which step a compliance workflow is currently on and what input is needed next. It names the specific resource (compliance workflow step) and a concrete verb (check), and the example queries distinguish it from related tools like get_progress.

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 usage triggers: 'Use this when someone asks...' with concrete example phrasings. It does not explicitly mention when not to use it or alternatives, but the context is clear and actionable for an agent.

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 meaningful behavioral context by specifying that the tool returns 'live advisory context' and includes CISA ICS/OT advisories with affected industrial products, indicating a comprehensive multi-source lookup. No contradiction with annotations.

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

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

The description is a single, well-structured sentence that front-loads the core purpose ('Get complete details') and efficiently lists the key outputs before giving a use case. Every word earns its place; no fluff 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 lack of an output schema, the description does an excellent job of conveying what the tool returns by enumerating seven distinct data categories, including the unique CISA ICS/OT advisory details. It also provides a practical use case, making the tool's broader context clear. The information is sufficient for an agent to decide when and how to use this tool.

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

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

Schema description coverage is 100% for all 4 parameters, with clear descriptions for each. The tool description lists the data types returned (CVSS, references, CPE, etc.) which partially maps to the include_* parameters, but does not add new parameter-level meaning beyond what the schema already provides. 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?

The description clearly states the tool's function: 'Get complete details for a specific CVE' and enumerates the specific data categories (CVSS scores, references, CPE mappings, KEV status, EPSS score, exploit references, CISA ICS/OT advisories). This specific verb+resource+scope distinguishes it from sibling tools that focus on individual aspects (e.g., get_epss_score, check_kev_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?

The description provides a clear context for use: 'use this to enrich an OT/ICS or robot-cell TARA with live advisory context.' It implies when to choose this tool over more specialized ones, but does not explicitly mention alternatives or exclusions. This matches 'clear context, no 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 and destructiveHint=false. The description adds valuable behavioral detail about the return payload (timestamps, age, counts, health status categories) and the exact data sources covered. It doesn't describe edge cases like partial failures, but for a read-only status tool this 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 two sentences: the first is a dense summary of functionality and outputs, the second is a clear usage recommendation. No filler or repetition of the name/title, and the most important information is front-loaded.

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

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

Despite lacking an output schema, the description fully enumerates the return fields and data sources, making the tool's behavior predictable. Given the zero-parameter input and simple read-only nature, the description covers all necessary context without requiring more detail.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly makes no parameter claims, and since the schema is empty, there is no additional documentation needed. The description adds value by explaining what data the tool actually 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?

The description clearly states the verb 'Check' and the resource 'freshness and sync status of all data sources', and it lists specific return fields (last sync time, data age, record counts, health status) and the covered sources (NVD, CISA KEV, EPSS, ExploitDB). This distinguishes it from sibling tools that target individual sources or specific details.

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 usage context: 'Use this to verify data is up-to-date before making security assessments.' While it doesn't name alternative tools or when NOT to use it, the context is clear and sufficient for an agent to decide when this 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=true and destructiveHint=false, so the tool's safety profile is known. The description adds value by specifying the return values (probability and percentile), but does not cover potential caveats like data freshness or error handling.

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

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

The description is two sentences long, front-loads the primary purpose, and contains no redundant information. Every word contributes to understanding the tool's function.

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 tool with no output schema, the description adequately explains the return format (probability and percentile). A mention of potential error behavior when the CVE is not found would make it fully complete, but it is otherwise sufficient.

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

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

The input schema fully documents cve_id with a pattern and description (100% coverage). The description aligns with the schema ('for a CVE') but adds no extra meaning beyond what the schema 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?

The description clearly states the tool retrieves the EPSS score for a CVE, with specific output context (probability within 30 days and percentile ranking). This distinctively separates it from sibling tools like get_cve_details or get_exploits.

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 explicit guidance is given on when to use this tool versus alternatives. The description implies usage for EPSS scores, but does not mention when not to use it or name alternative tools, leaving the agent to infer context from sibling names.

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 useful context by specifying that it returns 'references' (not exploit code itself) and lists aggregation sources. However, it does not describe result format or pagination, which would be additional behavioral 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?

The description is a single sentence of 14 words that front-loads the action and resource. Every word earns its place, 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 tool is simple with two parameters and good annotations. The description provides key context (sources, reference-only nature) and is sufficiently complete for a read-only lookup tool, though it could optionally mention the output shape (e.g., list of URLs).

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 explains cve_id format and verified_only default/filtering. The description adds no extra parameter-specific semantics, so 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?

The description uses a specific verb ('Get') and resource ('public exploit code references') scoped to a CVE, and enumerates concrete sources (Metasploit, ExploitDB, GitHub PoCs). This clearly distinguishes it from siblings like get_cve_details and search_cve.

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 clearly indicates when to use the tool: when you need exploit code references for a given CVE. It does not explicitly name alternative tools or exclusions, but the context is unambiguous given the sibling tool names.

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 description goes far beyond the existing annotations (readOnlyHint=true, destructiveHint=false). It discloses detailed behavioral traits: live usage counters, per-worker semantics, team/company pooling, UTC midnight reset, degraded-state service notices, and what each returned field means. This is exemplary transparency for a read-only introspection tool.

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

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

The description is well-structured with a clear lead sentence ('Tier, capabilities, limits, and live usage for the calling identity'), followed by usage guidance, then a detailed breakdown of the return document. It is somewhat long, but every sentence contributes meaningful information. It is not maximally concise, but it is efficient given the complexity of the output.

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 is fully complete for a zero-parameter, read-only tool with an output schema. It explains the purpose, usage context, behavioral details, and every field of the return JSON in detail. The existence of an output schema does not make this redundant; the description adds practical context (e.g., upgrade decisions, degraded states) that the schema cannot convey.

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

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

The tool takes no parameters, so the baseline is 4. The description explicitly states 'takes no arguments,' which is sufficient. Since there are no parameters, there is no additional semantic burden to carry.

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 verb ('get'), resource ('my capabilities'), and scope ('for the calling identity', including tier, limits, and live usage). It is specific enough to distinguish from most siblings, but does not explicitly name or differentiate from the similar-sounding 'describe_capabilities', 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 provides explicit guidance on when to use the tool: 'Use this to decide what tools and fan-out paths are available before calling them, or to check remaining quota before issuing more requests.' It also mentions the benefit of avoiding wasted retries and deciding on upgrades. However, it does not mention when not to use it or explicitly name alternatives, so it lacks full when-not/alternative coverage.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safe, read-only nature is known. The description adds value by specifying that the tool 'Returns completed and remaining steps with a progress percentage and quality score,' giving insight into the output structure and behavior beyond annotations.

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

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

The description is concise and well-structured: purpose statement, usage examples, and output summary in three short sentences. There is no fluff or redundancy, and the most important information is front-loaded.

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

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

For a simple read-only tool with one parameter and an output schema, the description adequately covers purpose, when to use, and what to expect in return. It is complete enough for an agent to select and invoke the tool correctly.

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

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

The schema description for workflow_id is complete (100% coverage), so the baseline is 3. The tool description does not add parameter-specific details, but the schema already provides sufficient meaning for the single 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?

The description clearly states the tool's function: 'See how far along a compliance workflow is and which steps remain.' It specifies the resource (compliance workflow) and the action (get progress), and distinguishes it from related tools like get_current_step by mentioning remaining steps and a progress percentage.

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 usage scenarios: 'Use this when someone asks how much of the gap analysis is done, what percentage is complete, or how many steps are left.' This gives clear context for when to use the tool, though it does not explicitly name alternatives or when-not-to-use cases.

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?

Beyond the readOnlyHint and destructiveHint annotations, the description discloses substantial behavior: transposition handling, the national vs. EU framework swap, the typed disclosure fallback, the 'Sources used' markdown table, and precise rendering rules (I1–I5). This far exceeds what annotations provide.

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 long but tightly organized and densely informative. It front-loads the core purpose, then logically groups addressing forms, transposition behavior, and rendering rules. Every sentence serves a purpose; 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?

Given no output schema and a complex tool with four parameters, multiple addressing forms, and nuanced transposition behavior, the description is exceptionally complete. It covers return values, edge cases, citation replay, and even user-facing rendering rules, leaving no critical usage 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?

While the schema already has 100% coverage, the description adds rich semantic meaning: it defines the three valid parameter combinations, gives concrete examples for each form, clarifies the role of jurisdiction alongside canonical_ref, and explains how law/article work for non-jurisdictional standards catalogs. This is meaningful 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?

The description opens with a clear verb and resource: 'Look up the exact text of a specific legal provision or standards-catalog control.' It then enumerates three distinct addressing forms with concrete examples, distinguishing this tool from sibling tools like search or probe_corpus.

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 guidance on when to use each addressing form, including specific user queries ('show me Article 5 of GDPR') and when to replay a canonical_ref from a search row's citation.lookup hint. It does not explicitly name alternative tools or offer when-not-to-use exclusions, but the context is strong enough to guide 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 declare readOnlyHint=true and destructiveHint=false, but the description adds far more: the meaning of 'enrolled' (verdict + acquisition proof), the freshness state vocabulary, and a warning about empty-search misinterpretation. This goes well 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?

The description is dense but well-organized: front-loaded with the core report scope, followed by a critical caveat about empty searches, then a concrete example query. Every sentence adds value and none feel repetitive or fluff.

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?

Even without an output schema, the description fully specifies what data is returned and how to interpret it. It covers the source list, freshness states, licensing verdict, and nuances like 'enrolled'. For a zero-parameter, read-only status tool, this is thorough and self-sufficient.

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

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

The tool has zero parameters and the schema is empty, so schema coverage is effectively 100%. The baseline for 0 params is 4; no parameter descriptions are needed or provided.

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 'Report' and clearly defines the resource: 'what this service actually monitors' and 'how current each source is'. It enumerates the exact attributes (sources, publisher, channel, jurisdictions, sync times, freshness states, record counts, verdict), making it unmistakable from siblings like get_data_freshness or list_coverage.

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 strong contextual guidance: 'Read this before concluding anything from an empty search' and explains what 'enrolled' means. It does not explicitly name alternative tools or when-not-to-use cases, so it stops short of full 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 and destructiveHint=false, so safety is covered. The description adds context about the prerequisite ('completed STRIDE analysis steps') and mentions that returns include severity ratings and mitigations, which is useful beyond the annotations but not deeply behavioral (e.g., no auth, rate limits, or error-handling nuances).

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 with no redundant phrasing. Front-loaded with the main purpose, followed by example queries and a summary of return content. 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 read-only tool with one parameter and an output schema, the description covers purpose, usage triggers, return content, and a prerequisite (completed STRIDE steps). The schema handles parameter semantics, annotations handle safety, and the output schema presumably handles return structure. Nothing significant 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 workflow_id parameter has a rich description in the schema itself ('as returned by start_workflow. Recover a lost id with list_workflows.'). The tool description adds no additional parameter meaning, so the baseline 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?

The description clearly states the tool's function with a specific verb ('Review') and resource ('threats identified during a threat-modeling workflow'). It also provides example natural-language queries ('what threats were found'), which helps the agent map user intent to the tool. This differentiates it from sibling tools like start_workflow or get_progress by focusing on the threat output.

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 says 'Use this when someone asks ...' with concrete example phrases, giving clear context for when the tool is appropriate. It does not mention alternatives or exclusions, but the context is strong enough to distinguish it from siblings without needing an explicit alternative list.

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 description adds important non-obvious behavior beyond the read-only annotation: laws/provisions counts are whole-jurisdiction totals even under a domain filter, with count_scope=whole_jurisdiction, and only sources/frameworks are domain-scoped. This prevents the agent from misreporting counts. No contradiction with annotations.

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

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

The description is dense but tightly organized: purpose, usage rule, examples, return shape, and a critical measurement warning. Each sentence adds value, and the examples are compact and illustrative rather than 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 exploration tool with an output schema and rich input descriptions, the description covers the return structure, edge-case semantics, and the relationship to sibling search. It gives the agent everything needed to invoke and interpret the tool 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?

Although the schema already describes all three parameters at 100% coverage, the description adds practical semantics: accepted alias values ('drone'/'uas'), example invocations, and the key caveat that domain only narrows jurisdiction/source lists, not counts. This goes beyond the 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?

The description clearly states the tool 'shows which countries, frameworks, and legal domains are available', using a specific verb and resource. It distinguishes itself from siblings by explicitly positioning it as a pre-search coverage/discovery tool that returns jurisdictions.

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

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

It provides an explicit directive: 'Use this BEFORE calling search when the user's topic doesn't name a jurisdiction', and instructs how to handle the returned jurisdictions. Concrete examples with query patterns make the invocation conditions 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 and destructiveHint=false, so the safety profile is known. The description adds behavioral context about pagination: 'Results are paginated with limit (default 20, max 100) and offset; follow next_offset until null.' It also lists the returned fields, which is useful beyond annotations. No contradiction with annotations.

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

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

The description is concise and front-loaded with the purpose. It uses four short sentences, each adding value: purpose, filters, pagination, and use cases. No redundant or filler content. Well-structured and easy to parse.

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 read-only nature, the presence of an output schema, and comprehensive annotations, the description covers all essential aspects: purpose, parameters, pagination behavior, and use cases. It is complete for a straightforward list operation, with no significant gaps in context.

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

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

Schema description coverage is 100%, and the description largely restates what the schema already provides (e.g., status values, limit default and max, offset semantics). It does not add significant new meaning beyond the schema, so the 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 the tool's function: 'List your organisation's workflows' with specific fields (id, type, status, current step, last update). This distinguishes it from siblings like list_workflow_types (which lists types) and get_current_step (which retrieves a specific step). The verb 'List' plus resource 'workflows' 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?

The description provides clear guidance on when to use the tool: 'Use it to recover a lost workflow_id or review past assessments.' This gives concrete use cases. However, it does not explicitly exclude alternatives or mention when not to use it, retaining a clear context but no 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 and destructiveHint=false, but the description adds substantial behavioral context beyond that: the tool is 'live' and authoritative, failures 'fail explicitly,' and no static list is returned as if live. It also details tier-locking behavior with caveats, such as 'a tier-locked row is never a bare false,' which is not inferable from annotations.

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

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

The description is a single dense paragraph but is front-loaded with the core purpose. Each sentence provides meaningful information: purpose, usage, output fields, tier behavior, and failure handling. It is longer than minimal but every sentence earns its place; no wasted words. The structure is logical and readable.

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

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

Given it has zero parameters and an output schema, the description is exceptionally complete. It explains the tool's role, when to invoke it, what fields each entry carries, how tier availability affects results, and how errors are handled. There are no significant gaps in understanding the tool's behavior and context.

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

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

The tool has zero parameters, so the schema covers 100% with nothing to explain. Per the baseline for 0-param tools, this earns a 4. The description adds value by describing the output fields (workflow_type, base_type, produces, required_slots, etc.), which is useful even though an output schema exists.

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 provides 'the authoritative live structured-workflow registry,' with specific verb and resource. It distinguishes itself from start_workflow by saying to call it 'before start_workflow instead of guessing an id,' and from static catalogs by emphasizing 'live.' It also enumerates covered workflow families, fully clarifying the tool's scope.

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 when to use this tool: 'Call this before start_workflow instead of guessing an id from examples or a static catalog.' It also explains tier-dependent availability, which is crucial for deciding whether a workflow can be started. It does not describe exclusions for other sibling tools, but the direct call-to-action and context are strong.

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, and the description adds useful constraints: 'Single-MCP diagnostic dispatch' (no fan-out) and the mcp:probe scope requirement. It does not detail error behavior, but the schema covers the unknown-id error.

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, front-loaded with the core purpose, then providing scope and restriction. Every sentence earns its place 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 tool is simple with only two required parameters, and an output schema exists. The description conveys the essential purpose, timing, and access restriction, which is sufficient given the rich schema and annotations. It could mention error behavior, but that is already in the 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 baseline is 3. The tool description itself contains no parameter-level guidance; all parameter semantics are already in the input schema. The extra 'Keep to plain concept terms' note appears in the schema, not the tool description, so no additional value is added.

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 purpose with a specific verb ('Test') and resource ('a specific data source'), and explicitly contrasts it with 'running a full search'. This distinguishes it from sibling tools like search and batch_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 description provides clear context on when to use the tool ('before running a full search') and includes an important restriction ('Not for customer use — requires mcp:probe scope'). It does not explicitly name alternative tools, but the timing and scope are well specified.

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?

Beyond the readOnlyHint, the description reveals what the tool returns: 'which analysis prompts to run, with what arguments, which can run in parallel, and an inline fallback for MCP clients that cannot invoke prompts.' This adds concrete behavioral context and confirms it is a planning-only operation.

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 compact sentences, front-loaded with the primary purpose, followed by the return shape and usage context. No wasted 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?

With an output schema present, the description need not detail return fields, but it summarizes them anyway. It covers the phase enum, the source of the ID, the optionality, and the fallback behavior, making it complete for an AI agent to select and invoke correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value by linking phase_id to 'get_current_step' and noting that 'Richer context produces a more specific breakdown,' which goes beyond the bare schema definitions.

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 specific verb+resource: 'Plan the parallel sub-analyses for a threat-modeling phase.' It clearly distinguishes this tool from siblings by focusing on workflow phase planning and returning a breakdown, rather than executing or mutating workflow state.

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

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

It explicitly says when to use: 'Optional — the workflow works without it; use it to speed up large systems by fanning phases out to subagents.' It also tells the agent where the phase_id comes from (get_current_step), which is a clear contextual trigger.

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=false and destructiveHint=false, so the description adds the context that this resumes a paused workflow. It does not disclose specific side effects or state changes, but with annotations the bar is lower. The description adds moderate value beyond the 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 sentences, front-loaded with the purpose, then usage examples, then the prerequisite. Every element earns its place with no redundancy or fluff.

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 (one parameter, no required fields, output schema present). The description combined with the schema fully covers what the agent needs: what it does, when to use it, and how to obtain the workflow_id. 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 coverage is 100% and the schema description for workflow_id already explains it comes from start_workflow and can be recovered via list_workflows. The description repeats the requirement without adding new parameter nuances, so it earns the baseline for high 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 states the tool continues a paused or interrupted compliance workflow, using a specific verb ('Continue') and resource ('compliance workflow'). It also distinguishes from siblings by giving concrete example utterances and referencing start_workflow as the origin of the required ID.

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 explicit usage scenarios with example phrases and a clear prerequisite (workflow_id from start_workflow). It does not explicitly mention when not to use or name alternative tools, but the context is clear enough to guide 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?

Beyond the readOnlyHint=true annotation, the description discloses determinism, unmetered access, tier-independent recommendations, snapshot freshness (fetched_at, age_seconds), explicit failure on missing/stale snapshots, and the fact that no static catalog is served as live. This substantially exceeds the annotation baseline.

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 long but dense; the first sentence front-loads the purpose, and every subsequent clause adds needed operational detail. Slightly verbose for the format, but aptly sized for an interactive tool with snapshot, tier, and failure-mode nuances.

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 output schema presence and complexity, the description fully covers the iterative question/response cycle, final recommendation details, authorization visibility, snapshot metadata, and disagreement handling with list_workflow_types. Failure modes are also specified; no significant gap remains.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds interactive usage context: all arguments optional, take values from previous question options, use ['unscoped'], and the typical invocation example. The schema already carries the detailed field descriptions, so the marginal value is useful but not transformative.

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 precise verb and resource: 'Scope a compliance workflow down to ONE concrete workflow id'. It clearly distinguishes itself from siblings by stating it answers what the catalog cannot and explicitly contrasts with list_workflow_types. The return behavior (question vs recommendation) is also specified.

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 explicit when-to-use and when-not-to-use guidance: call with any known info, use list_workflow_types and start_workflow directly for unlisted frameworks, and re-scope on registry changes. Includes a concrete typical opening example with parameters.

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 only declare readOnlyHint=true, openWorldHint=false, destructiveHint=false. The description goes far beyond that: tier limits (free vs solo vs premium), scope-refusal behavior (REFUSED, not ignored), intersection semantics, FTS5 implicit AND, stripping of uppercase operators, NO_STRICT_MATCH meta fields, allow_broadening behavior, and citation-table rules. This is a rich behavioral disclosure with no contradiction to annotations.

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

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

The description is long but well-structured with clear sections, bulleted examples, and a logical flow from purpose to constraints to response handling. Most sentences earn their place given the tool's complexity. It does repeat the 'at least one scope' requirement multiple times, and some tier-limit details could be condensed, but the overall structure supports readability.

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 complexity (tier limits, multiple scope types, broadening, strict-match behaviors, citation requirements) and the absence of an output schema, the description is remarkably complete. It covers how to handle zero results, how to interpret meta fields, how to render the sources table, and what to do when recommended_action is RETRY_ONE_CONCEPT_PER_CALL. No important aspect seems 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 schema already provides 100% coverage with descriptions for all 7 parameters, but the tool description adds substantial meaning beyond the schema: tier-dependent scope limits (one jurisdiction/framework in free tier), specific source IDs for licenses, query-shape best practices, and examples mapping natural-language intents to parameter values. It also clarifies interactions like jurisdictions x sectors intersection and frameworks filtering behavior.

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

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

The description clearly states 'Find laws and regulations on a specific topic' and explicitly differentiates from sibling tools: it notes that there is no separate search_case_law or search_preparatory_works tool, and that search_guidance is available for agency-guidance-only queries. It also positions itself against list_coverage for topic-without-country cases. The verb+resource+scope is specific and immediately understandable.

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 'Use this when' guidance is provided with examples ('what does the law say about X in country Y'). It names alternatives (search_guidance, list_coverage), gives a prerequisite (call get_my_capabilities before large batches), and even specifies when NOT to use certain patterns (e.g., license questions need explicit sources=). The description gives clear decision rules for scoping and broadening.

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 clear. The description adds no additional behavioral context such as pagination, rate limits, or result format, so it only minimally adds to what annotations provide.

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 only two sentences, with no unnecessary words. Both sentences contribute to understanding the tool's purpose and typical use, making it highly concise and well-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?

Given the tool's moderate complexity (5 parameters, all documented) and strong annotations (read-only), the description is adequate. It conveys the core purpose and use case, while the schema covers parameter details. The lack of an output schema is offset by the clear implication that the tool returns CVE data.

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 all parameters are well-documented in the schema. The description only mentions product and version conceptually, which doesn't add new 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 tool finds CVEs for a specific product and version, which is a specific verb+resource. It distinguishes itself from generic search tools by emphasizing specificity, but doesn't explicitly differentiate from sibling tools like search_cve.

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 clear context for use: vulnerability assessment of software components. It implies the tool is for targeted CVE lookups but does not provide exclusions or mention alternative tools, so it doesn't fully meet the 5-criteria.

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 valuable behavioral context by stating the return payload includes CVSS scores, KEV status, and EPSS data, and that full-text search on descriptions is supported. No contradictions with annotations.

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

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

The description is three sentences and about 40 words. It is front-loaded with the primary action, followed by return data and an alternative tool reference. Every sentence earns its place without 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?

Even though there is no output schema, the description specifies the key return fields (CVSS, KEV, EPSS) and points to get_cve_details for deeper information. It does not mention pagination limits or result ordering, but the schema covers the limit/offset parameters. For a complex 12-parameter search tool, the description provides sufficient context without needing to enumerate every aspect.

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 each parameter already documented concisely. The description's reference to 'keyword, severity, score range, and filters' is a high-level summary that doesn't add meaning beyond the schema. The note about full-text search on descriptions duplicates the keyword parameter's schema description.

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 purpose: 'Search CVEs by keyword, severity, score range, and filters.' It specifies the resource (CVEs) and the action (search), and distinguishes itself from get_cve_details by directing users there for full details on a specific CVE. The verb+resource+scope is specific and actionable.

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 names get_cve_details as an alternative for full information on a specific CVE, which provides a clear when-not-to-use signal. However, it does not contrast with other search-related siblings like search_by_product or batch_search, leaving some ambiguity about when to use this tool over those.

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 only indicate readOnlyHint=false and destructiveHint=false; the description adds that starting 'SPENDS a run from the monthly allowance' and that cancellations don't refund on free/solo tiers. It also explains the dynamic enum behavior (caller-authorized vs string) and the server-enforced human-input gate. This is substantial behavioral context beyond the structured fields, with no contradiction.

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

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

The description is comprehensive but dense, packed into one long paragraph with many conditional clauses. It is not broken into sections, and the critical call-list_workflow_types-first guidance is buried mid-paragraph. However, each sentence contributes necessary operational detail, which is justified given the tier and run allowance complexity.

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 tier fencings, run accounting, dynamic enums, and step-gate behavior, the description covers all required concepts: registry, variants, alternatives, quotas, and outputs (JSON or watermarked reports). An output schema exists to detail return values, so omission is acceptable. It gives the agent everything needed to decide when and how to call.

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

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

Schema coverage is 100%, but the description adds critical semantics: workflow_type is an exact id from list_workflow_types, not a guess, and the enum is caller-authorized with a stale-catalog caveat. It explains the framework argument's tier restriction to four values and the default behavior. Entity_description is described as grounding the first steps, adding to schema explanations.

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 'Begin a structured workflow selected from the live workflow registry,' clearly identifying a specific verb and resource. It distinguishes from sibling tools like list_workflow_types and cancel_workflow by focusing on starting, not listing or canceling. The registry coverage enumerates many workflow families, making the tool's scope unambiguous.

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

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

It explicitly instructs to 'Call list_workflow_types first' as the authoritative source for ids and availability, and to check get_my_capabilities and obtain user approval before spending a run. It explains tier restrictions and run consequences, giving clear when-to-use and pre-call steps. No explicit 'when not to use' but alternatives are implicitly covered through the referral to sibling 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?

The description explains that 'The workflow engine validates the response and advances to the next step,' revealing the tool's side effects beyond the annotations. It also highlights the guardrail against misrepresenting automation as human review by asserting approved_by only accepts 'auto', which is valuable behavioral context not present in the annotations.

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

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

The description is detailed but every sentence earns its place: it opens with the purpose, followed by usage triggers, then key parameter behaviors, and closes with the auto-approval caveat. It is appropriately sized for a tool with 9 parameters and complex gating semantics, with no filler.

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

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

Given the complex input schema, the description covers the critical context: what the workflow does, when to use it, how to handle evidence references, and how to correctly assert human vs. automated approval. With an output schema present, it doesn't need to explain return values, so the description is complete for an agent to select and invoke the tool correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful semantic nuance by providing real-world examples of responses, clarifying evidence_references accepted formats, and reinforcing the distinction between approved_by='auto' and user_acknowledged for human review, which goes beyond the schema parameter 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?

The description uses a specific verb+resource construction: 'Provide an answer to the current step in a compliance workflow.' This clearly distinguishes the tool from siblings like start_workflow, cancel_workflow, and get_current_step by focusing on submitting a response for the current step.

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

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

The description explicitly states 'Use this when someone provides information requested by the workflow' and gives concrete examples. It also covers conditional usage for unattended gates, clearly specifying when to set approved_by='auto' and user_acknowledged=false, which orients the agent on when to use this variant.

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?

Beyond annotations (readOnlyHint=true, openWorldHint=false, destructiveHint=false), the description adds important behavioral context: it returns the current served text, clarifies that a valid verdict only means the citation resolves in the served corpus, and discloses the output includes a 'Sources used' table with rendering rules. This does not contradict annotations.

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

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

The description is front-loaded with a clear purpose sentence and usage guidance, but the lengthy block of detailed rendering rules (I1–I5) adds verbosity. While these rules are content-relevant, they could be condensed without losing essential information, preventing a perfect score.

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?

Even without an output schema, the description thoroughly explains the return value (current served text, Sources used table) and the interpretation of the verdict. It also covers limitations and alternative tools, making it complete for a tool of this 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%, so parameters are already well-documented. The description adds examples ('Article 28 GDPR') but no additional semantic detail beyond the schema. Per the rubric, baseline 3 is appropriate when schema covers parameters fully.

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 purpose with a specific verb and resource: 'Verify a legal citation against the served corpus' and explains it confirms existence and retrievability, returning the current text. It also distinguishes from the sibling tool 'diff' by explicitly noting the difference (citation validation vs. provision-level change comparison).

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 ('use this when someone asks...'), explains how to answer a specific query (compare returned text with claim), and states what it does NOT do (does not assert in-force status, does not consult amendment feeds). It also names an alternative: 'For a provision-level change comparison use diff.'

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