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 states the text is processed locally, never modified, and no sanitized representation is returned. It also discloses conditions like 'debug responses are enabled' and the policy_not_found error, giving a complete picture of side effects and edge 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 dense but well-organized: a one-line purpose statement, then usage guidance, alternatives, and return format all in a compact sequence. Every sentence adds value; there is no fluff or repetition, and the critical scoping constraint ('without producing sanitized output') 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?

The tool has 3 parameters, all fully documented in the schema, and an output schema (implied via the described JSON structure). The description explains the return object thoroughly, including conditional fields for review/debug modes, and covers error behavior for unknown policies. Nothing an agent needs to invoke it correctly is missing.

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

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

All three parameters already have descriptive schema entries (coverage 100%), so the baseline is 3. The description adds meaningful context beyond the schema: it explains the effect of response_mode on the return structure, describes the policy error condition, and reiterates local-only processing for the text parameter. This extra context justifies a 4 rather than a baseline 3.

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

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

The description opens with a specific verb-resource pair ('Inspect text locally') and explicitly distinguishes the tool by stating it reports sensitive content 'without producing sanitized output.' This clearly differentiates it from siblings like prepare_for_external_ai and create_safe_copy, making its purpose immediately 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 gives explicit when-to-use guidance: 'Use this when you need to understand what PII, secrets, or credentials are present... but do not need redacted text for transmission.' It then names three alternatives with their appropriate contexts (prepare_for_external_ai, create_safe_copy, restore_text), leaving no ambiguity about tool 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?

No annotations are present, so the description carries the full burden—and it excels. It discloses side effects: writes a new file to SECUREDACT_SAFE_COPY_DIR, does not modify 'content', never overwrites an existing file, blocks with status 'blocked' under specific conditions, and returns a JSON structure. This is a thorough disclosure of behavior 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 well-structured: core action first, then usage guidance, then side effects, then return format. Each paragraph adds distinct value with no redundancy. Concise yet complete, and front-loaded with the most important decision-driving information.

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

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

Given the tool's moderate complexity (3 parameters, no nested objects), an output schema exists (per signals), and the description itself explains side effects, blocking conditions, filename constraints, and return format. Nothing an agent needs to call it correctly is missing. The description is fully self-contained even without annotations.

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

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

Schema coverage is 100%, so the schema fully describes all three parameters. The description adds practical context (e.g., filename must be bare, policy defaults to 'strict_external_ai', content is never transmitted) but does not materially enhance the semantic 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?

States a specific action ('sanitize text locally and write the approved result to a new file'), names the resource ('Safe Copies directory'), and explicitly differentiates from all four siblings by naming them and the conditions under which each is preferred. An agent can immediately tell this tool writes a sanitized copy to disk.

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 second paragraph gives explicit when-to-use guidance: 'Use this when you need a sanitized on-disk copy... rather than an in-memory sanitized string,' and names the alternative tools (prepare_for_external_ai, analyze_text, restore_text) with their complementary use cases. This fully eliminates ambiguity about tool 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?

With no annotations provided, the description carries the full transparency burden and does well by stating that the tool does not transmit text externally, operates locally, can return different statuses, and optionally creates a restoration session. It also discloses the policy_not_found error behavior. It could go slightly further on whether any local state or session data is persisted, but overall it is transparent for a sanitization 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 front-loaded with the primary use case, then a clear sibling-routing paragraph, then a concise output contract. Every sentence earns its place, and the structure makes it easy for an agent to scan quickly.

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 when to use the tool, how it behaves, what alternatives exist, and what the return value looks like including statuses and optional fields. With a rich input schema and output schema present, nothing essential is missing 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%, and the input schema already explains text, policy, language, and response_mode in detail. The description adds little new parameter-level meaning beyond the schema, but the schema is fully sufficient, 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 states a specific use case: preparing user-supplied or sensitive text before sending it to an external AI service, with local sanitization via SecuRedact. It clearly differentiates from siblings by naming each alternative and its purpose (analyze_text, redact_text, create_safe_copy, restore_text).

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

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

It explicitly recommends this tool as the default for outbound AI workflows and gives concrete routing rules: analyze_text for inspection-only, redact_text for lower-level compatibility, create_safe_copy when a file is needed, and restore_text only for reversing a prior local session. This leaves little ambiguity about when to choose it.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It transparently warns that legacy mode 'returns potentially sensitive local-review details' and 'must never be sent to an external service', and specifies the return contents (status, sanitized_text, counts) for normal modes. It also notes local processing, adding essential context about data 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 concisely structured: the first sentence directly states the routing preference, followed by a clear explanation of normal vs. legacy behavior, and finally the return contract. Every sentence earns its place, with 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 the tool's three parameters and existing output schema, the description covers all necessary context: when to use it, what it returns, the special legacy mode with its sensitive nature, and the difference from its sibling. No critical information is missing for correct invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful value for response_mode by clarifying that normal modes 'behave like prepare_for_external_ai' and that the legacy value exposes original values, which is not fully captured in the schema. This extra explanation helps an agent avoid misusing the sensitive legacy path.

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

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

The description clearly identifies this as a 'Direct/lower-level redaction entry point' and explicitly states it performs 'the same local sanitization as prepare_for_external_ai', distinguishing it from the preferred sibling. It names the action (redact), the resource (text), and explains the optional legacy mode, leaving no ambiguity about what the tool does.

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

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

The description gives explicit guidance: 'prefer prepare_for_external_ai for normal outbound workflows' and 'Use redact_text when you specifically need this lower-level compatibility path, or the legacy mode'. It names the alternative tool and the precise conditions for choosing this one, fully satisfying the when/when-not requirement.

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 full responsibility for behavioral disclosure. It reveals that processing is entirely local and nothing leaves the machine, that the mapping form requires trusted_local_review=true and exposes raw originals that must never be transmitted, and it details the return format including 'status', 'restored_text', and 'reason_codes' for failures. This goes well beyond the schema and covers security-boundary concerns comprehensively.

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 structured with a clear lead sentence stating the core action, followed by usage conditions and security boundary in a logical flow. Every sentence contributes new information—no redundancy or fluff—and the critical constraints (local-only, trusted-review) are front-loaded. The length is justified by the security-sensitive nature of the operation.

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 security-sensitive restoration tool with no annotations and no explicit output schema details (though an output schema exists), the description is remarkably complete. It covers preconditions, security boundaries, parameter interactions, failure handling via reason_codes, and explicitly routes to the correct sibling for sanitization. Nothing an agent needs to call it correctly and safely is missing.

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

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

Schema coverage is 100%, so the baseline is 3. However, the description enriches the parameters: it explains the mapping parameter as 'legacy direct mapping' that bypasses the session vault and immediately reveals originals, describes restoration_session as an opaque token identifying the trusted vault entry, and clarifies that trusted_local_review is an acknowledgment with no effect on the session form. These security-relevant semantics add 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 uses a specific verb 'Reverse' and identifies the resource as 'a prior SecuRedact protection step', clearly stating the local trusted-review purpose. It explicitly distinguishes itself from sibling tools by warning against using it for external AI preparation and pointing to prepare_for_external_ai for that role, so it is immediately differentiated.

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

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

The description gives explicit preconditions: use only after receiving a restoration_session from SecuRedact (e.g., from prepare_for_external_ai with response_mode 'restore_capable'), and never on text not previously protected. It also names the alternative tool and states the exact negative condition ('never call it to sanitize or prepare text for an external AI'), leaving no ambiguity about when to choose this tool.

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

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

With no annotations, the description fully owns behavioral disclosure. It spells out side effects (reads file, never transmits), the defense order (sensitive paths and escapes blocked before reading), and the return structure. It even notes sanitized_text is safe to forward. This is thorough and anticipates an agent's security and safety questions.

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: purpose sentence, usage trigger, alternatives, side-effects, and return format. Every sentence serves a distinct function with no redundancy. The most important info (what it does and when to use it) 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?

Given the output schema is present, all return fields are covered. The description addresses security, policy defaults, size limits, and side effects. There is nothing an agent needs to know to call this tool correctly that is missing or ambiguous.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The tool description itself does not add new meaning beyond what's in the schema, but it does echo the security posture (e.g., path defenses). Baseline 3 is appropriate because the schema carries the load and the description adds no extra helpful nuance.

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: 'Safely read a local file and return only its sanitized text.' It clearly distinguishes from siblings by naming prepare_for_external_ai (in-memory content) and create_safe_copy (sanitized file on disk), so the agent can immediately tell which tool to use.

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 states the condition for use: 'when you must ingest a local file's contents for use with an external AI' and gives two alternatives with the contexts under which those would be preferred. This is direct routing guidance.

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