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

Annotations already declare readOnly=false, idempotent=true, destructive=false, but the description adds valuable context: the list is checked by audit_text, and the global vs. style-specific scoping with merge behavior is disclosed. This gives the agent a clear model of side effects and scope.

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

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

Three sentences, front-loaded with the core function, then expansion on scoping and usage triggers. No redundant words or repetition of schema details.

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

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

For a two-parameter tool with no output schema, the description covers the essential behavior (add, check via audit_text), the two modes (global/style), and the usage context. It is complete enough for an agent to select and invoke correctly without further clarification.

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?

Even though schema coverage is 100%, the description adds meaningful semantics to styleId by explaining the global vs. scoped behavior and the merge on top of the global list. Word is self-evident, but the styleId enrichment is significant.

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 'Add' and the resource 'banned-words list', and immediately contextualizes it as being 'checked by audit_text'. It distinguishes itself from siblings like remove_banned_word and add_custom_word by specifying the list type and the audit_context.

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 triggers ('when the user says something like...') and details when to use the global list vs. a style-scoped list via styleId. This goes beyond vague 'use for adding banned words' and gives actionable 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?

The description goes beyond the annotations by explaining the merge behavior (style-specific list merged on top of global) and the effect of never flagging the term even if it matches a banned word. It does not contradict the idempotentHint annotation and provides useful context that the schema and annotations alone don't convey. Minor gaps exist around permissions or error handling, but they are not critical.

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, front-loading the primary action in the first sentence and then providing context and usage examples. Every sentence adds value, with no repetitive or unnecessary content. The length is appropriate for 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?

Given the simple two-parameter tool with no output schema and helpful annotations, the description provides sufficient context about purpose, effect, and behavior. It covers the most relevant aspects, though it omits details about return values or possible validation errors. These are minor and not critical for a tool of this simplicity.

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 meaningful semantics beyond the schema for styleId, clarifying that 'merged on top of the global list' and that omitting styleId targets the global list. It also reinforces the purpose of the word parameter with a practical example. This incremental information justifies a 4.

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

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

The description clearly states the action ('Add a term to this installer's own allowed-words list'), the resource (the list), and the intended effect on audit_text. It also distinguishes itself from banning words and explains the global vs style-specific scope, which differentiates it from sibling tools like add_banned_word or remove_custom_word.

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 user-phrase triggers ('add [word] to my custom words list' or 'stop flagging [word], it's one of ours') and clarifies when to use global vs style-scoped additions. It does not explicitly mention alternative tools for when not to use it (e.g., if the user wants to ban a word), 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?

Annotations already declare read-only and idempotent; description adds determinism, config-file reading, strengths signal, and never-silent-rewrite promise. This enriches behavioral understanding beyond annotation hints.

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?

Dense but efficient paragraph front-loads the core action; every sentence contributes, but length may be slightly overwhelming. Could use paragraph breaks for 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?

With no output schema, description fully explains return values (tier, score, findings, strengths). Also covers config file integration and usage philosophy, making the tool's contract clear.

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 all parameters with descriptions (100% coverage). Description reinforces styleId merging and register calibration but adds no new syntactic detail beyond schema.

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

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

Clearly states it deterministically scans non-fiction text for AI-writing tells, listing specific patterns and output categories. Distinguishes from sibling tools focused on style management and narrower checks like check_voice_match.

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 context: show the user what's flagged and why, only rewrite on request. Implies a broader audit role versus siblings but doesn't explicitly name alternatives or exclusions.

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

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

Annotations already declare safe read-only/idempotent behavior, and the description adds valuable context: it lists the two specific repetition patterns, empty-list behavior for insufficient history, local-only history tracking, and a caution not to over-trust results. 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?

Four sentences, each earning its place: purpose, distinction from audit_text, usage conditions including empty-list behavior, and a trust-mode warning. Information is front-loaded and compact 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?

Even without an output schema, the description fully sets expectations: what the tool detects, when it may return empty, platform differences, and how to interpret its signal. This is sufficient for an agent to 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?

Input schema covers all three parameters with clear descriptions: text, styleId, and deprecated id alias. The tool description adds context about trained voices and recent samples but does not substantially enhance parameter-level meaning beyond the schema, 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 specifies a clear action: comparing drafted text against a trained voice's samples to detect two named types of self-repetition. It explicitly differentiates from audit_text ('not AI-writing tells') and ties to train_style, making its purpose distinct among siblings.

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

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

Directs users to use audit_text for AI-writing tells, and states that the tool is only meaningful for voices trained from real samples with at least 3 samples, otherwise returning empty findings. It also notes hosted/remote differences and advises against rewriting solely on this signal, covering when-to-use and 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?

Goes beyond the readOnlyHint/idempotentHint annotations by disclosing what the tool returns (verdict, score, drifted dials, caveat), the low-confidence behavior on short input, and a crucial interpretive limitation (not an authorship/AI-detection check). This gives the agent a realistic expectation of outputs and edge cases.

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 carries information: comparison semantics, timing, return values, caveat, confidence guidance, and prerequisite condition. It is front-loaded with the first sentence stating the core action, and the rest expands logically.

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

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

Given the tool has no output schema, the description compensates by explicitly stating what is returned (verdict, match score, drifted dials, caveat, confidence). It also covers the prerequisite about trained/custom voices and the provisional nature of low-confidence results, making the operation fully self-contained.

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 for parameters is 100%, so the schema already explains text, styleId, and id. The description adds contextual meaning by stating the styleId must refer to a trained or custom voice and that bare presets won't work, which is useful but not essential for parameter use.

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: 'Compare a piece of drafted text's measured sentence/paragraph rhythm and mechanics against a trained or custom voice's baseline', and enumerates the measured dials (sentence length, rhythm variance, etc.). This clearly distinguishes it from sibling tools like check_self_repetition, which checks repetition, or audit_text, which audits generally.

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 prescribes when to use it: 'Use this after drafting in a voice to check whether the draft's rhythm actually landed close to it, instead of just eyeballing it.' It also defines an exclusion and a workaround: 'Only works against trained or custom voices... not bare presets... fork_style a preset first if you want to check a draft against one.'

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 state the operation is mutating and idempotent. The description adds that it clears the scope 'leaving it empty', which clarifies the end state. There is 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 15-word sentence, front-loaded with the action verb and precise scope. Every word contributes meaning.

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 one optional parameter, no output schema, and clear annotations, the description plus schema fully cover the operation. The scope of removal is explicitly stated.

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 describes styleId with reference to list_styles and the global-instruction behavior, achieving 100% coverage. The description does not add parameter-level details, so the baseline score of 3 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 uses the specific verb 'Remove' and identifies the resource as 'saved instructions for a scope', clearly distinguishing it from siblings like set_style_instructions and get_style_instructions. It also explicitly mentions global vs. specific style scopes.

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 the tool is for removing saved instructions, and the schema adds that omitting styleId clears global instructions. However, it does not explicitly name alternatives or exclusion criteria, though the sibling context makes the intended use obvious.

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 indicate idempotent behavior, but the description adds specific context: 'Call again with the same name to overwrite' and the fact that dials map onto the same measurements as train_style, ensuring a dial-built style is equivalent to a trained voice. This enriches the behavioral model without contradicting 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 compact and front-loaded, with no fluff. Each sentence serves a purpose: purpose, use case, dial structure and equivalence, overwrite behavior. It is dense but logically organized and appropriate for 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?

The description covers the core purpose, usage scenarios, parameter grouping, and overwrite semantics. It lacks details on return values or success behavior, but no output schema exists and the sibling set provides context. Minor gap is acceptable given the strong annotation coverage and clear description.

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

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

Schema coverage is 100%, so the baseline is 3. However, the description adds meaningful grouping ('3 persona dials... plus 8 mechanical dials') and clarifies the semantics of entropy ('how much AI-typical structural regularity to break'), providing context not fully captured in individual field 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 states a specific verb+resource: 'Build a style profile from explicit dial values' and clearly distinguishes from train_style by contrasting with 'writing samples'. It also explains the two categories of dials and ties the output to the same measurements as train_style, making the tool's unique role 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 states when to use the tool: 'for when the user wants to hand-tune a voice (or doesn't have samples handy)' and names the alternative tool (train_style) when samples are available. The overwrite note also guides behavior on repeated calls, making usage direction clear.

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 indicate destructive and non-read-only behavior. The description adds that deletion is permanent and does not affect presets, which are useful behavioral nuances 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 long, front-loaded with the primary action, and includes a necessary scope clarification in the second sentence. No wasted words.

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

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

For a destructive delete tool with two well-documented parameters and no output schema, the description plus annotations cover the essential context: what it deletes, permanence, and scope. No major 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 coverage is 100% and both parameters have clear descriptions. The tool description only says 'by id' without specifying which parameter, so it adds no additional 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's function: permanently deleting a trained voice profile by id. It distinguishes between trained voices and premade presets, which aligns with the sibling tools and title.

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 clarifies that premade presets are not affected, implying this tool is for trained voices only. It doesn't explicitly name alternatives, but the context is sufficient for an agent to know when to use it.

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

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

Annotations indicate readOnlyHint=false and openWorldHint=true. The description adds significant behavioral detail: a public-style fork makes one network call to etincel.ai while a preset fork stays local, and the original style is untouched. This goes beyond the annotations by clarifying side-effect scope and non-destructive 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 about 100 words, organized in three sentences: action, source types with examples, and outcome. It is dense but every sentence conveys essential information. Slightly long for the tool's complexity, but the structure is logical and front-loaded with the core purpose.

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

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

Covers the two source modes, network behavior, non-destructive nature, and the relationship to retraining/hand-tuning. Does not explain error handling or return values, but with no output schema and the tool's moderate complexity, this is acceptable. The description provides enough context for an agent to pick 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 covers 100% of parameters, so baseline is 3. The description adds value by explaining the dual meaning of styleId, giving the 'handle/slug' format and concrete examples, and noting that presetId is a deprecated alias. This clarifies how to address both source types beyond the schema's generic descriptions.

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

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

Description states 'Copy a style into a new trained voice under the given name' with a specific verb and resource. It distinguishes two source types (preset vs published community style) and clarifies the result is a normal trained voice, differentiating it from sibling creation tools like create_style_from_dials. The title also reinforces the 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?

The description specifies when each source type is appropriate (preset vs public gallery address) and notes the network call implication for public forks. It references post-fork alternatives (train_style, update_style) but does not explicitly state when to choose fork_style over create_style_from_dials, though the context implies it is the starting point for existing styles.

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 read-only, idempotent, non-destructive, so the safety profile is covered. The description adds valuable behavioral context beyond annotations, such as the fact that .etincelrc team-wide instructions are folded into every style's instructions, not just 'team''s, and that the tool is context, not an action.

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 moderately detailed but every sentence earns its place. It front-loads the core function, then explains return content, special folding behavior, and usage context without 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?

Given the simple single-parameter interface, the description is remarkably complete. It explains what the return value contains, how .etincelrc affects results, and when to use the tool. There is no output schema, so the description appropriately covers return semantics.

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 documents styleId as a preset, trained voice, or 'team'. The description adds further meaning with a concrete example ('direct-warm') and clarifies the semantics of 'team' in relation to .etincelrc, going beyond the schema's 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 fetches the full drafting guide for one style, with specific examples of style IDs and the special 'team' case. It also distinguishes itself from prose-writing tools by explicitly saying it is context for the drafting model, not a tool that writes prose itself.

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 usage instruction: 'Read this before drafting.' It also explains what the tool returns and the context in which it is used (drafting or revising). However, it does not explicitly name alternative tools or state when not to use it, though this is implied by the drafting 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?

Annotations already declare the operation as read-only, idempotent, and non-destructive, so the bar is lower. The description adds useful behavioral detail: it returns saved instructions for a scope, and for a style it also returns the effective merged text. This goes beyond the structured annotations without contradicting them.

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 core action and scope, and no wasted words. Every sentence contributes to understanding the tool's behavior and its relationship to get_style_guide.

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 optional parameter, the description is sufficiently complete. It covers the global/scope distinction, the style-specific behavior including merged text, and the relationship to get_style_guide. No output schema exists, but the description gives a clear idea of what the tool returns.

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 reinforces the semantics of the optional styleId (global vs style) and mentions list_styles indirectly, but the schema already documents the omit-for-global behavior. The description adds little 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 uses a specific verb ('Show') and resource ('saved instructions for a scope'), clearly distinguishing global vs style-specific context. It also differentiates from the sibling get_style_guide by noting that get_style_guide already folds in the effective merged 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 explains the optional styleId scope and the default global behavior, and explicitly relates to get_style_guide by noting what get_style_guide already does. It does not provide explicit 'when not to use' guidance, but the context is clear enough for the agent to choose between this and get_style_guide.

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 the tool safe (readOnlyHint=true, idempotentHint=true, destructiveHint=false). The description adds valuable behavioral context: the tool returns the effective merged list for a style (style words plus global words), which is exactly what audit_text applies. This goes beyond the annotations without contradicting them.

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

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

Two concise, front-loaded sentences. Each sentence contributes unique information: scope options and the merged-list behavior. 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?

Given the tool has one optional parameter, no output schema, and clear annotations, the description is sufficient. It explains what is returned for the global and style cases, including the merged-list concept. The absence of output schema detail is acceptable for a read-only list 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 coverage is 100% and the parameter description already explains styleId (look up style list, omit for global). The description adds further meaning by clarifying the default scope and the merged-list result when styleId is provided, so it enhances understanding of parameter impact.

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 a specific verb ('Show') and resource ('banned-words and custom words lists'), and distinguishes between the global list and a style-specific list. It also differentiates from sibling tools by explaining that this tool reads dictionary lists, not styles or audit results.

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: the global list is the default, and a styleId looks up a specific style's list. It also mentions the effective merged list and its relation to audit_text, which tells the user when the result matters. It does not explicitly name alternatives, but it's clear from scope and purpose.

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 indicate readOnlyHint, idempotentHint, and destructiveHint false, covering the safety profile. The description adds valuable behavior context: it lists styles from multiple sources and conditionally includes a team style only if .etincelrc defines one, which is not inferable 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?

A single, information-dense sentence that packs purpose, scope, and usage guidance without redundancy. It is front-loaded with the key action and reads naturally.

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 list tool with no output schema, the description fully covers what the tool returns (all available styles) and when to invoke it. The conditional team style nuance is also disclosed. No missing 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 input schema has zero parameters, so the baseline is 4 per rubric. The description reinforces that the tool lists every style with no filtering, which adds semantic clarity beyond the empty 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 begins with a specific verb and resource: 'List every available style.' It enumerates the categories of styles (premade emotional-tone presets, user-trained voices, conditional team style), clearly distinguishing this listing tool from sibling tools that create, update, or delete styles.

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 when to use the tool: 'Call this before drafting or revising non-fiction prose if the caller hasn't been told which style to use, or if the user asks what styles exist.' This provides clear contextual guidance without needing to reference 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 convey that the operation is a mutation (readOnlyHint=false), idempotent, and non-destructive. The description adds scope detail (global vs. style-specific) but doesn't explain consequences like whether the word is immediately allowed or what happens if the word isn't banned. No contradiction with annotations, but little extra behavioral depth.

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 that conveys the action, resource, scope, and optionality. Every word earns its place; 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 two-parameter mutation tool without an output schema, the description plus schema provide enough information to invoke correctly. It could mention that removing a ban is idempotent or what happens upon success, but given the low complexity, the current info is nearly 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 descriptions cover both parameters fully (word and styleId, with styleId referencing list_styles and global omission). The tool description adds no new parameter meaning beyond echoing 'global, or a specific style's list.' With 100% schema coverage, this 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 uses a specific verb ('Remove') and resource ('term from this installer's banned-words list'), and clearly distinguishes the scope ('global, or a specific style's list'). This differentiates it from sibling tools like add_banned_word and remove_custom_word, making the purpose unambiguous.

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

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

The description gives clear context: it is for removing a banned word, with optional style scoping. It implies the agent should use this when unbanning a term, but it doesn't explicitly name alternatives or exclusions (e.g., 'for custom words, use remove_custom_word'). Still, the context is sufficient for correct 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 already indicate idempotentHint=true and destructiveHint=false, so the safe mutation nature is known. The description adds the global/style-scoping context but does not disclose potential error behavior (e.g., fails if word not found) or side effects beyond removal, which are not covered by 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 one concise sentence, front-loaded with the action, and contains no redundant words. Every phrase 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 removal tool with two parameters, good annotations, and no output schema, the description covers the core operation and parameter semantics adequately. It could mention behavior on non-existent terms, but given the simplicity, it is sufficiently 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 coverage is 100%, so baseline is 3. The description adds meaning by clarifying that omitting styleId targets the global list, while providing it targets a specific style's list, directly enhancing the semantics of the styleId 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 verb 'remove' and the resource 'a term from this installer's allowed-words list', with explicit scope of 'global, or a specific style's list'. This distinguishes it from siblings like remove_banned_word and add_custom_word.

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 the use case (removing an allowed word) but does not explicitly state when to use this vs alternatives like remove_banned_word or add_custom_word. It provides context about global vs style-specific scope but lacks explicit when-to-use or exclusions.

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

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

Annotations already indicate the operation is idempotent and non-destructive. The description adds meaningful behavioral context by stating the effect is persistent ('going forward') and the benefit (avoids re-specification), which goes beyond the structured hints without contradicting them.

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 action and purpose. Every word contributes to understanding the tool's function, with no extraneous 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?

For a simple 2-parameter setter with full schema coverage and no output schema, the description fully explains what the tool does and its effect. The context is complete enough for an agent to select and invoke it correctly without further elaboration.

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

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

Schema coverage is 100%, with both parameters described in the schema (styleId and its deprecated alias id). The description adds no additional parameter-level details, so it relies on the schema's own descriptions, making the baseline of 3 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 action ('Set'), the resource ('default style'), and the scope ('for this user going forward'). It distinguishes itself from sibling tools like list_styles or delete_style by focusing on setting the default, not managing styles themselves.

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

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

The description implies when to use it ('so it doesn't need to be re-specified every time'), giving clear context on its purpose. It does not explicitly name alternatives or exclusions, but the context is sufficient for selecting this tool over related style-management 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?

Beyond the annotations (write, idempotent, non-destructive), the description discloses the critical behavior of overwriting existing instructions for the scope. It also clarifies merge semantics with global instructions and how get_style_guide returns the merged result, providing context not 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?

Every sentence is purposeful and informative. The description is front-loaded with the core purpose, followed by clear examples and scope behavior. 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 has no output schema, but the description fully covers when to use it, overwriting behavior, global/specific scope, merging, and return behavior via get_style_guide. It is a complete guidance for an agent invoking this setter.

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 both parameters already have descriptions. The description adds extra nuance about merge behavior and global vs. specific scope, which exceeds the schema but is not entirely new since the schema's styleId mentions global instructions. Thus a strong 4.

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: saving free-text drafting rules layered on top of a style's voice. It lists explicit examples of content types (required elements, audience notes, forbidden topics) and distinguishes scope (global vs. specific style), differentiating it from siblings like update_style and clear_style_instructions.

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 with user quotes ('always end with a CTA') and explains when to use global vs. style-scoped instructions. It also references get_style_guide for reading merged results, effectively guiding the agent to the correct alternative.

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

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

Since all annotations are false, the description carries the full behavioral burden. It discloses that the tool persists data, blends new samples into existing measurements rather than replacing them, and never fabricates from a description. It also details the metrics measured (sentence length, contraction rate, etc.) and explains the id fallback behavior, which goes well beyond the minimal 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 not bloated; each sentence contributes to understanding the tool's purpose, usage, and behavior. It is front-loaded with the core action and logically organized. While somewhat long, the length is justified by the tool's complexity and the need to cover metrics, id fallback, and limitations.

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 quite comprehensive: it explains the persistent effect, the incremental training behavior, the id fallback, and the limitation against fabrication. However, it does not describe the return value or potential error conditions, which would be useful given there is no output schema. Still, for the tool's complexity, the description is largely 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?

The schema already covers 100% of parameter descriptions, giving a baseline of 3. The description adds meaningful usage semantics: the 'name' parameter can be reused to add training data, and the 'id' or 'styleId' can target a voice even after a rename. This enriches the static schema definitions with dynamic usage patterns.

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: it analyzes the user's writing samples and persists a trained voice profile. It uses specific verbs like 'Analyze' and 'persist', and distinguishes itself from sibling tools by explicitly noting it never fabricates a voice from a description, only learning from real text. This makes the purpose unambiguous and 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 usage context: call again with the same name and new samples to add training data, and pass the voice's id from list_styles if the voice may have been renamed. It also implies when not to use it (when a description is given, not real samples). It does not name a specific alternative tool, but the context of siblings like create_style_from_dials makes the distinction clear enough.

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

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

The description provides important behavioral details beyond the annotations: it explains that mechanical dials are ignored for sample-trained voices, while persona dials always apply. It also notes that the id and default-style pointer remain stable. This is critical context for understanding what the tool does and what side effects occur, significantly surpassing the annotations' idempotent and non-destructive hints.

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 carries no redundant information. Every sentence adds essential context: the action, the stable identifier, and the conditional behavior of mechanical dials. It is compact 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 complexity (nested dials object, conditional behavior, no output schema), the description covers the key nuances effectively. It explains which dials apply in which scenario, which is the most important ambiguity. Minor omissions like explicitly stating that 'name' can be unchanged or that the styleId must be specified are already covered by the schema descriptions, so the description itself is complete enough for effective use.

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

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

The schema already provides descriptions for all parameters (100% coverage), so the baseline is 3. The description adds value by grouping the dials into persona (always apply) and mechanical (conditional) categories, clarifying how the 'dials' parameter behaves in practice. This enriches the semantics beyond the individual 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 clearly states the tool's function: 'Rename a trained voice or adjust its dials in place.' It specifies the exact resource (existing custom style) and the scope (keeping id and default-style pointer stable). This distinguishes it from sibling tools like create_style_from_dials or fork_style, which create new styles.

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 'in place, keeping its id stable' clearly indicates this tool is for modifying an existing style rather than creating or forking. It implies when to use it, though it does not explicitly name alternative tools for new styles. The context is clear enough for an agent to infer the appropriate use case.

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