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

No annotations are provided, so the description carries the burden. It discloses that notes are timestamped, attributed, and form part of an audit trail for regulators, which is useful behavioral context. However, it doesn't mention whether notes can be edited or deleted, whether appending is the only operation, or any permission requirements. The audit-trail statement implies immutability but doesn't state it explicitly.

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 with no waste. The core action is front-loaded, and the use-case examples are packed into the final sentence. Every sentence earns its place.

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

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

For a simple two-parameter append tool, the description is nearly complete. It explains the audit-trail significance, which is the key non-obvious context. It doesn't describe the return value, but there's no output schema and the operation is simple enough that an agent can infer success from a standard response. The only minor gap is not stating whether notes are immutable.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds context about what the note should contain (transaction hashes, counterparty findings, analyst rationale) but doesn't add syntax or format details beyond the schema. 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 states a specific verb ('Append'), a resource ('investigation note to a case'), and the purpose ('document transaction hashes, counterparty findings, or analyst rationale'). It clearly distinguishes from siblings like kyt_create_case or kyt_get_case, which operate on cases at a different level.

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 clear context for when to use the tool: to document investigation findings, transaction hashes, or analyst rationale. It doesn't explicitly name alternatives or state when not to use it, but the use cases are specific enough that an agent can infer the right context.

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

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

With no annotations provided, the description must carry the full behavioral burden. It discloses that the case is opened with status='open' and linked to the most recent screening, and mentions bundling of evidence, notes, and audit trail. However, it does not state potential side effects (e.g., whether the screening is marked as resolved), permissions required, or reversibility. This is moderate disclosure but lacks depth for a mutating tool.

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

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

The description is two sentences with zero fluff. The primary purpose and key behavioral detail (tied to most recent screening) are front-loaded, followed by the required parameter. 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?

There is no output schema, so the description should explain what the tool returns. It does not mention the response format, such as whether a case ID is returned or how to retrieve the created case. It also omits error conditions and any prerequisites (e.g., that a screening must exist). For a creation tool with no output schema, this is a significant gap.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds specific meaning for the 'address' parameter by linking it to the trigger and the most recent screening, which goes slightly beyond the schema. For 'chain' and 'notes', no additional semantics are added, so the value is marginal. 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 verb (open), the resource (compliance case), and the specific context (from a flagged screening). It also describes what a case bundles (evidence, notes, audit trail) and distinguishes it from sibling tools like kyt_screen_wallet and kyt_get_case by focusing on the creation action.

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: after a flagged screening, passing the address that triggered the alert. It also specifies the behavior (opens under your org, status='open', tied to most recent screening). However, it does not explicitly mention alternatives or when not to use it, leaving some inference to the 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates that the tool returns plain text, is for review, and explicitly notes it is decision-support, not auto-filing, which clarifies side effects and responsibility. This is valuable context beyond the schema.

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

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

The description is two sentences, front-loaded with the core action and output, and the second sentence adds a critical responsibility caveat. Every word contributes value; there is 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?

For a simple tool with one parameter and no output schema, the description adequately explains the output format (plain text), its purpose, and the compliance responsibility. It does not detail error handling or invalid inputs, but these are minor for such a straightforward generation tool.

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

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

The schema covers 100% of the parameter (case_id) with a description, and the tool description only restates 'for a case' without adding new meaning. The baseline of 3 is appropriate since the schema already documents the parameter adequately.

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 'Generate', the resource 'Suspicious Activity Report draft for a case', and adds specificity with 'FinCEN-aligned' and 'BSA E-Filing System'. It is unambiguous and easily distinguished from sibling tools like kyt_screen_wallet or kyt_lookup_intel, which serve different purposes.

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

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

The description implies usage for generating SAR drafts but does not explicitly state when to use it versus alternatives, nor does it mention exclusions or prerequisites. While the purpose is clear, there is no guidance on when not to use it or what distinguishes it from other case-related 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?

With no annotations, the description carries the transparency burden. 'Fetch' signals a read operation and the phrase 'including evidence notes and screening linkage' discloses response content, but it does not explicitly state that the operation is side-effect-free or describe not-found/error behavior.

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

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

The description is a single, front-loaded sentence with no filler. The core action and resource appear first, and the additional content detail is appended without redundancy.

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

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

For a one-parameter read operation with no output schema, the description is nearly complete: it names the input key, the resource, and key return content. It loses one point because it does not provide any explicit guidance on what happens when the case ID does not exist or how to handle the screening-linkage field.

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

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

Schema description coverage is 100%, and the single parameter case_id is already documented as 'Case UUID.' The description adds no new semantic detail about the parameter 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 uses a specific verb ('Fetch'), names the resource ('a single case'), scopes it by 'ID', and even previews contents ('evidence notes and screening linkage'). This clearly differentiates it from siblings like kyt_list_cases and kyt_create_case.

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

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

The use case is implied: use this when you have a case UUID and need the full case record. However, it does not explicitly state when to prefer this over alternatives, such as using kyt_list_cases to find IDs first or kyt_recent_screenings for screening-focused results.

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

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

With no annotations, the description must fully disclose behavior. It states the success case (returns 'ok' when responsive) but does not specify what happens when the engine is not responsive—whether it returns an error, throws, or returns a different status. This is a significant gap for a health probe.

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

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

The description is a single, concise sentence that front-loads the purpose. It contains no extraneous information and is appropriately sized for the tool's simplicity.

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 incomplete for a health probe because it only covers the healthy response and omits failure behavior. Without an output schema, the description should specify possible return values or error semantics, but it does not. This is a clear gap given the tool's purpose.

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 is trivially complete. The description does not need to add parameter details. Baseline for 0 params is 4, and there is no issue here.

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 is a backend health probe that returns 'ok' when the engine is responsive. This is a specific, unambiguous purpose that distinguishes it from the screening, lookup, and case management siblings, which all perform distinct operations.

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

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

The description implies this tool is for checking service availability, but it does not explicitly state when to use it versus alternatives, nor does it mention any conditions or exclusions. The usage context is implied rather than articulated.

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

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

With no annotations, the description carries the behavioral burden. It discloses scope (organisation's cases), read-only nature via 'List', and the returned field set. It does not cover pagination, ordering, or authorization, but for a simple list operation the core behavior is transparent.

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

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

Two compact sentences with the verb first, followed by use case and output fields. No filler or repetition of schema data.

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

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

For a low-complexity list tool with no required params, the description supplies the key invocation context: what it returns and when to filter. The lack of an output schema is mitigated by the explicit field list, though pagination behavior is left implicit in the schema's limit parameter.

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

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

Schema covers both parameters with descriptions and enum values, so the baseline is 3. The description reinforces the status filter's purpose ('needing review or escalation') but adds no new parameter details beyond the schema.

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

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

States a clear verb ('List'), resource ('your organisation's compliance cases'), and the available filter dimension. Mentioning included fields distinguishes it from list screenings or single-case tools like kyt_get_case.

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

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

Explicitly tells the agent when to use it: to list cases and filter by status for review or escalation. It does not name sibling alternatives or state when not to use it, so it stops short of a full routing rule.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool returns tiered labels (T1-T4) with source attribution, and indicates it is a lightweight lookup rather than a full screen. This conveys the operational behavior (cheap, focused) and the nature of the output, though it does not explicitly state whether it is read-only or mention any side effects.

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 sentence states the purpose and primary return; the second adds the tier details and usage context. It is front-loaded, with no redundant information, and every clause contributes to decision-making.

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 a simple one-parameter tool and no output schema, the description adequately explains what the tool returns (tiered labels with source attribution) and when to use it. It does not describe error handling, but this is a minor gap given the tool's simplicity. An agent can confidently invoke it based on the provided information.

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%: the only parameter, 'address', is described as 'Wallet address to look up.' The description reinforces this without adding new details about the parameter itself. The baseline of 3 is appropriate because the schema already fully documents the parameter, and the description's context does not provide extra semantic value beyond confirming the purpose.

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 ('look up') and resource ('known intelligence labels for an address'), and explicitly distinguishes itself from a 'full screen'. This directly differentiates it from sibling tools like kyt_screen_wallet, so an agent can quickly identify its niche.

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 states a clear usage condition: 'use when you only need to know whether an address is known,' and emphasizes it is 'cheaper than a full screen.' It does not explicitly name the alternative tool, but the context strongly implies kyt_screen_wallet. This is sufficient guidance for selecting between them, though a sibling mention would have been more explicit.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation through the verb 'List' and describes the returned fields, but it does not explicitly state that no side effects occur, how results are ordered, or any access/rate-limit considerations. Adequate but not rich.

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

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

Two sentences with no filler. The first states the action and scope, the second gives a practical use case and the output fields, making the description easy to parse and 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?

Given the tool's simplicity, the description is nearly complete: it covers purpose, usage context, and return fields. It lacks explicit mention of ordering or time-window semantics beyond 'recent', but for a one-parameter read tool this is a minor gap.

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

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

There is only one parameter, limit, and the schema description coverage is 100% (default 20, max 200). The description adds no parameter-specific detail, but since the schema fully documents the parameter, 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 uses a specific verb and resource: 'List recent screenings performed by your organisation.' It clearly distinguishes this tool from siblings like kyt_screen_wallet (performing screenings), kyt_stats (aggregate stats), and kyt_list_cases (case listings). The mention of returned fields further clarifies 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?

The description gives clear usage context: 'Useful for catching up on what teammates or automated pipelines have been screening.' It does not explicitly name alternatives or when not to use it, but the context is sufficient for an agent to understand the intended scenario.

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

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

With no annotations provided, the description takes on the full disclosure burden. It discloses the core behavior, return payload, speed, and auto-detection logic. It doesn't mention failure modes, rate limits, or network dependencies, but for a read-only screening tool the disclosed behavior is reasonably transparent.

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

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

The description is concise and front-loaded: it states the action, data coverage, and output in the first two sentences, then adds contextual speed guidance. It earns its length, though the enumerated return fields make it slightly dense.

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

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

Given there is no output schema)Skip{}... Actually, the tool lacks an output schemaache but important behavioral context. The description covers inputs, outputs, performance, and use-case timing. Missing only explicit comparison to sibling screening/lookup tools, which would make it fully complete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds a useful reiteration that chain is auto-detected and lists address formats, but this largely mirrors the schema rather than adding substantial new semantics.

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 ('Screen') with a clear resource ('a single wallet address'), enumerates the exact data sources consulted, and states the concrete output (risk score, signals, exposure, summary, recommendation). The tool is easily distinguished from siblings like case management or stats tools.

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

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

It gives explicit contextual guidance: 'Use this BEFORE settling on-chain' and highlights the <200ms fast-path cache for sanctioned wallets. However, it doesn't name specific sibling tools or state when to prefer alternatives like kyt_lookup_intel, leaving some selection judgment to the 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?

With no annotations, the description carries the full burden. It clearly indicates a read-only stats retrieval by saying it returns coverage statistics and enumerates the type of data returned. It does not mention authentication, rate limits, or response format, but for a simple informational tool the behavioral disclosure is largely sufficient.

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

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

Two tightly written sentences deliver the purpose, key output contents, and an explicit use case without wasted words. The most important information is front-loaded with the verb and resource.

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

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

For a zero-parameter, low-complexity tool, the description is fairly complete: it identifies the output contents and use case. It does not specify the exact response shape, but with no output schema and no annotations a bit more detail about the returned format would make it fully self-sufficient.

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

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

The input schema has zero parametersaine schema coverage is effectively 100%, so the baseline is 4. The description adds no parameter details because none are needed; it appropriately focuses on what the stats contain instead.

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 ('Return') with a precise resource ('KYT coverage stats') and lists the concrete contents: total labeled addresses, per-tier breakdown, data sources, and update cadence. This clearly distinguishes it from sibling tools focused on screening, lookups, cases, or health checks.

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 'Useful for compliance documentation' provides a clear context for when to use this tool. It does not explicitly mention alternatives or exclusions, but the use case is evident enough to guide selection among the sibling tools.

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