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

With no annotations, the description carries the burden of behavioral disclosure, and it does clearly signal a read operation with no side effects. But it does not describe what the returned health data looks like, whether it attempts network connectivity, or what failure conditions look like; for a zero-parameter health check, this is acceptable 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?

A single, precise sentence states the operation and target with no filler. Every word earns its place and the structure is easy for an agent to parse.

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

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

This is a trivial zero-parameter tool with no output schema, so the description is nearly sufficient. It misses only an explicit statement of what the agent should expect in the response (e.g., status OK versus failure), but the health-endpoint wording strongly implies that 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 and 100% schema description coverage, so the baseline is 4. The description correctly requires no parameter explanation because there are none to document.

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 ('Read') and a specific resource ('the runtime bridge server plugin health endpoint'), clearly identifying what the tool does. It implicitly differentiates from siblings like st.bridge.read by focusing on the health endpoint, though it does not explicitly name alternatives.

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 intended use is implied: it is the tool to call when checking the health state of the runtime bridge server plugin. However, it gives no explicit guidance about when not to use it or how it compares to diagnostic siblings like st.doctor or st.bridge.read.

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 must carry the full behavioral disclosure burden. It mentions a confirmation gate, but does not describe side effects, what gets modified, whether installation is reversible, failure behavior, or return value. This is thin for a mutating install operation.

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

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

The description is a single, front-loaded sentence that states the action and resource, with the confirmation requirement placed second. There is no redundant filler, though more behavioral detail would be welcome.

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

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

Given no annotations, no output schema, and a non-trivial install operation, the description leaves important context unexplained: how this differs from generic plugin/extension installs, what the bridge installation entails, and what to expect in the response. An agent would need additional inference to use this tool confidently.

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 provides only a boolean 'confirm' with no description, so the description must add meaning. 'Requires confirm: true' clarifies that the tool expects an explicit true value, which is useful, but it does not explain why confirmation is needed or what happens if confirm is absent or false.

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 ('Install') and identifies a specific resource: the ST MCP runtime bridge server plugin and frontend extension. This is specific enough to distinguish it from generic install tools, though it does not explicitly contrast with sibling tools like st.plugin.install or st.extension.install.

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 only usage guidance is 'Requires confirm: true,' which is a call requirement, not guidance on when to choose this tool over alternatives. No exclusions, prerequisites, or alternative selection criteria are provided, even though sibling install tools exist.

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 behavioral burden. 'Read' implies a non-mutating operation, but the description does not disclose what happens with the optional history parameter, whether data can be stale, whether the bridge must be running, or what the response contains. This is a thin disclosure for an unannotated 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 one tight sentence with no filler and the core resource is front-loaded. It is concise, but brevity edges into under-specification becuase it costs key parameter and behavior 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?

There is no outut schema, no annotations, and the only paramter is undocumented. The ststement identifies what is read but not how the 'history' paramter affects behavior, what is returned, or whether any setup is required. For a tool with this little structure, the descrition should do more work.

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 0%, and the description does not mention or explain the single 'history' boolean parameter. An agent has no way to know whether 'history' controls returning historical snapshots, including prior results, or something else. The description adds no parameter meaning whatsoever.

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 identifies a specific verb ('Read'), a specific resource ('latest browser runtime snapshot'), and a specific source ('ST MCP runtime bridge'). It is clearly distinguishable from siblings like st.resource.read and st.snapshot by describing the exact snapshot 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 implies the tool is used to retrieve a snapshot from the bridge, which gives some context. However, it does not explicitly state when to prefer this over st.snapshot, st.resource.read, or other read-style tools, nor does it mention prerequisite conditions like bridge health.

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 or output schema, the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, but the description does not explain what the returned chat files look like, whether simple or metadata parameters alter results, or whether any pagination/ordering applies.

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 padding or redundant information. It states the essential action and scope efficiently.

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 listing tool the description covers the basic purpose, but it is not complete enough given the total absence of parameter descriptions, annotations, and output schema. The agent is left to guess the meaning of optional parameters and the return format.

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 0%, and the description does not compensate for the three parameters. The 'avatar' parameter is only implicit in 'for one character avatar', while 'simple' and 'metadata' are entirely unexplained, leaving agents without enough information to use them correctly.

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 ('List'), a clear resource ('chat files'), and a clear scope ('for one character avatar'). This distinguishes it from sibling tools like st.character.list (listing avatars) and st.chat.inspect (inspecting a specific chat).

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 no guidance on when to choose this tool over alternatives, nor any exclusions or prerequisites. An agent must infer usage purely from the tool name and terse description.

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

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

There are no annotations, so the description carries the transparency burden. It discloses that the operation is a patch (partial update) and that confirmation is required. However, it does not explain side effects, whether snapshots are involved, failure modes, or reversibility, leaving meaningful behavioral ambiguity.

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

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

The description is a single dense sentence with the purpose front-loaded and a critical requirement appended. Every word earns its place, and there is no repetition 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?

Given the nested 'fields' object, the required avatar parameter, and the absence of an output schema, the description is too sparse. It does not explain how to structure field values, what avatar refers to, what snapshotLabel does, or what the tool returns, so the agent must infer too much.

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 0%, so the description must compensate. It adds meaning to 'fields' with examples and clarifies that confirm must be true, but it leaves the required 'avatar' parameter and 'snapshotLabel' unexplained. This is insufficient for an agent to confidently construct a valid request.

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 ('Patch') and a specific resource ('core character card fields'), with concrete examples like description, personality, scenario, greetings, and prompts. It makes the tool's purpose clear, though it does not explicitly differentiate it from generic siblings like st.resource.patch.

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 the tool: when patching core character card fields. It also gives a key invocation requirement ('Requires confirm: true'), which is useful. However, it does not explicitly say when to prefer this over st.resource.patch or other character-related tools, so routing guidance is mostly implicit.

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

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

With no annotations provided, the description carries the full burden. It clearly indicates a read-only operation, which rules out mutation concerns, but it offers no detail on return shape, error behavior, or any non-obvious behavior. The disclosure is minimal yet not misleading.

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 tight, front-loaded sentence with no filler. It states the action first and then the result scope, making it easy to parse 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?

For a single-parameter read tool the description is close to adequate, but it lacks an explanation of the 'avatar' parameter and does not mention how a valid avatar value is obtained. With no output schema, the description also leaves the exact return contents only vaguely specified through 'core editable field list'.

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 has one required parameter, 'avatar', with 0% description coverage and no enum or format details. The description does not compensate by explaining what 'avatar' should be, where to obtain it, or how it identifies a character, so an agent must infer its meaning from the name alone.

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 names a specific verb ('Read'), a specific resource ('one character card'), and a specific scope ('core editable field list'). It naturally distinguishes itself from siblings like st.character.list and st.character.configure by targeting a single card for reading.

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 intended use is implied: inspect a single character card when you need its editable fields. However, the description gives no explicit guidance about when to choose this over st.character.list or how it relates to st.character.configure, leaving selection partly to inference.

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 burden of behavioral disclosure. It clearly states the operation is read-only ('reads imported cards') and non-creating ('does not create cards'). This is sufficient for a parameterless list tool, though it doesn't describe return format or ordering.

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 short sentences with no filler. The primary action is front-loaded, and the read-only clarification earns its place by preventing misuse.

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, parameterless listing operation with no output schema, the description conveys enough: what the tool lists, that it reads imported cards, and that it does not create cards. An agent can invoke it correctly without additional context.

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

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

The tool has zero parameters and the schema coverage for parameters is 100% (empty properties), so the baseline is 4. The description adds no parameter-level detail, but none is needed because there are no parameters to document.

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: 'List existing SillyTavern characters.' It also explicitly contrasts with creation ('does not create cards'), which distinguishes it from potential write operations 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?

The description provides clear context for when to use the tool (to list existing characters) and an explicit exclusion (not for creating cards). It does not name sibling alternatives like st.character.inspect for detailed single-character inspection, so it stops short of full routing 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?

With no annotations, the description must carry behavioral weight. It usefully signals a mutation ('override fields') and a non-obvious requirement ('confirm: true'). However, it does not disclose side effects on existing chat_metadata fields, behavior of force/enabled, or what happens when unspecified fields are absent.

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 compact sentence with the main action front-loaded and no filler. Every word contributes functional guidance, and it is structured for quick parsing.

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?

An 11-parameter setter with no annotations, no output schema, and zero parameter descriptions needs far more context than a single purpose-and-precondition sentence. The description covers intent and one precondition, but leaves most parameter semantics and behavioral edge cases undefined.

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 0%, so the description must compensate, but it only adds semantic weight to avatar, fileName, and confirm. The other eight parameters—role, text, depth, force, enabled, interval, position, snapshotLabel—remain unexplained, leaving the low-coverage gap largely unaddressed.

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 clear action with object and scope: 'Set the current-chat Author's Note override fields in chat_metadata.' This distinguishes it from generic siblings like st.chat.metadata.patch by naming a specific sub-resource. It does not explicitly name alternative tools, which keeps it from a 5.

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

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

The description gives a concrete precondition ('Requires explicit avatar/fileName and confirm: true') and an explicit target, but it does not say when to prefer this over related setters such as st.chat.metadata.patch or st.chat.variables.set. The usage context is implied from the tool name rather than spelled out.

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 for behavioral disclosure. The verb 'Read' implies a non-mutating operation, but the description does not disclose permissions, failure behavior, or whether any state is affected. It only restates the schema requirement that both parameters are needed.

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. It states the operation and resource first, then adds the parameter requirement without unnecessary detail.

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

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

For an unannotated tool with no output schema, the description leaves important gaps: the semantics of avatar, how fileName relates to chat files, and how this differs from nearby chat inspection tools. It communicates the broad action but not enough to ensure 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 description coverage is 0%, so the description needed to explain avatar and fileName, but it merely restates their requiredness without defining what they mean or how they should be formatted. An agent cannot determine valid values from this text.

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 action ('Read') and a concrete resource ('chat file header, chat_metadata, and messages'), which clearly identifies what the tool does. The listed components also distinguish it from single-purpose chat metadata or message manipulation sibling tools, even though no sibling is named explicitly.

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 tool is for reading chat-derived data, but it gives no explicit guidance on when to choose this over st.chat.metadata.get or other chat-related tools, and it does not mention exclusions. The use case is inferable but not explicitly framed.

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 disclosure burden. It states the core behavior of appending, highlights the mandatory confirm:true value (not visible in the schema's required array), and explicitly says content is not generated. It omits details like side effects or return shape, but the central 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?

A single, front-loaded sentence captures the purpose and key constraints with no filler. The clause 'caller-provided' earns its place by separating this tool from message-generation flows.

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?

This is a mutation tool with six parameters, zero schema descriptions, and no output schema. The description leaves required parameters semantically unexplained and omits behavior for force and snapshotLabel, so it is not complete enough for fully safe invocation without external docs.

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 0%, so the description must compensate. It clarifies 'message' (caller-provided) and 'confirm' (must be true), but says nothing about required parameters avatar and fileName, nor about the ambiguous force and snapshotLabel parameters. Several invocations would be guesswork based on property names alone.

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 action ('Append') and a resource ('chat transcript'), and clarifies the message is caller-provided rather than generated. This clearly distinguishes it from siblings like st.chat.message.edit or st.chat.message.delete and from content-generation 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 an explicit precondition: confirm:true is required. It also states what the tool is not for ('does not generate message content'), which provides an implicit exclusion. However, it does not name alternative tools or explain when to prefer this over message editing or injection 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?

No annotations are provided, so the description carries full responsibility. It discloses the destructive nature ('Delete') and the confirm requirement, but does not state what happens to transcript indices after deletion, whether the action is reversible, or whether snapshotLabel is used to snapshot state before deletion. This is a meaningful gap for a destructive 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?

Two sentences, no filler. The essential action, target, and safety requirement are front-loaded. Every word earns its place.

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

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

For a destructive mutation tool with no annotations and no output schema, this is incomplete. It lacks details about which parameters are required for identifying the message (avatar and fileName are required but unexplained), how index behavior changes after deletion, the role of force, and what happens to snapshots. The agent would need to infer too much.

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 0%, and the six parameters are undocumented. The description adds meaning for two parameters: index ('zero-based transcript index') and confirm ('requires confirm: true'). However, it leaves avatar, fileName, force, and snapshotLabel unexplained, which is a notable gap given no schema descriptions exist.

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 verb ('Delete') and resource ('one existing chat message'), plus the disambiguating mechanism ('zero-based transcript index'). This clearly distinguishes it from siblings like st.chat.message.edit and st.chat.message.append.

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: it deletes one message by transcript index, and explicitly requires confirm: true, which conveys a safety gate. It does not explicitly contrast with st.chat.message.edit or explain when deletion is preferred over editing, but the context is clear enough for an agent.

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

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

With no annotations provided, the description carries the full burden. It discloses a key behavioral requirement: confirm must be true for the edit to proceed. However, it does not mention the destructive/irreversible nature of editing, required permissions, or side effects on fields other than the message body.

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 core action and the critical confirm requirement are front-loaded, and every word earns its place.

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

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

For a mutation tool with 8 parameters, no annotations, no output schema, and 0% schema coverage, the description is incomplete. It covers the index and confirm semantics but leaves the required avatar/fileName parameters unexplained, making it impossible to call correctly without external knowledge.

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 0%. The description clarifies two of eight parameters: 'index' (zero-based meaning) and 'confirm' (must be true). It completely ignores the required parameters 'avatar' and 'fileName', which would leave an agent guessing about their semantics, and also ignores force, fields, message, and snapshotLabel.

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 ('edit'), a specific resource ('existing chat message'), and the unique addressing mechanism ('zero-based transcript index'), which clearly distinguishes it from sibling tools like st.chat.message.append and st.chat.message.delete. The purpose is unambiguous.

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

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

The description implies the use case: when you need to modify an already-sent message rather than appending or deleting one. However, it does not explicitly name alternatives or state conditions like 'use append for new messages', so guidance is only implicit.

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 disclosure burden. 'Read' clearly communicates a non-mutating operation, and 'Requires explicit avatar and fileName' signals strict identifier requirements. However, it does not disclose return behavior, error conditions, or permission requirements.

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 short sentences with the main purpose front-loaded. The second sentence is partly redundant with the schema's required list but does add the 'explicit' nuance, so it is not entirely wasted. Overall concise and easy to scan.

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 parameter descriptions, no output schema, and no annotations, making the description the sole source of context. It gives the purpose and required parameters but not the meaning of avatar/fileName, the return shape, or error behaviors. An agent could invoke it but without confidence about expected results.

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 0%, so the description must compensate. It only restates that avatar and fileName are required (already shown in the schema) and adds the vague qualifier 'explicit' without explaining what values are acceptable, how they relate to the ST chat file, or how to obtain them.

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 ('Read'), the resource ('chat_metadata'), and the scope ('from a specific ST chat file'). It is easy to tell apart from st.chat.metadata.patch based on the read/patch contrast, but it does not explicitly distinguish itself from similarly named siblings like st.chat.inspect.

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?

Usage is implied by the verb 'Read' and the resource name, but no explicit when-to-use or when-not-to-use guidance is given. 'Requires explicit avatar and fileName' hints at prerequisites but does not point to an alternative tool for cases where those are not available.

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 disclose side effects; it only notes that confirm=true is required. It doesn't state whether the patch is destructive/reversible, how force or unset alter behavior, or what happens on failure.

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 single sentence is tight and front-loaded, with no wasted words. However, brevity comes at the cost of critical detail.

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

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

For a 7-parameter nested-object mutation tool with no output schema and no annotations, this is far too thin. Core operational semantics for force, confirm, unset, updates, and snapshotLabel are missing.

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

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

Schema description coverage is 0%, and the description adds only the 'dotted paths' clue. Seven parameters including force, unset, updates, and snapshotLabel are left entirely unexplained.

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 verb ('Patch') and resource ('chat_metadata dotted paths' in a specific ST chat file). It distinguishes the target from generic patch tools like st.resource.patch, though it doesn't explicitly name sibling 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?

No guidance on when to choose this over st.chat.metadata.get, st.config.patch, or st.mvu.chat_state.patch. The only operational note is 'Requires confirm: true', which is a precondition, not usage 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, the description carries the full burden of behavioral disclosure. It does state that the operation persists and requires confirmation, which is useful. However, it doesn't disclose side effects, irreversibility, permission needs, or edge cases around delete/update.

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 sentence, front-loaded with the action and resource, and includes the important confirm requirement without 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?

Given 13 undocumented parameters, no output schema, and no annotations, this short description is not enough for an agent to configure the tool correctly. It captures the general purpose but leaves most of the configuration semantics implicit.

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 0%, and there are 13 parameters with no descriptions. The description adds one meaningful note about confirm: true, but does nothing to explain value, role, position, force, filter, delete, snapshotLabel, or how they interact with create/update/delete.

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 specific actions (create/update/delete), the target resource (chat_metadata.script_injects), and the nature (persistent slash-command-style prompt injection). It doesn't explicitly compare to siblings such as st.prompt.set_injection, but the resource path and style distinguish it.

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

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

No when-to-use guidance or alternative routing. The only additional instruction, 'Requires confirm: true', is a precondition rather than context for choosing this tool. With many sibling configuration tools available, this is a clear gap.

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 and does reveal the mutation behavior, storage location, and confirm requirement. It does not explain side effects such as snapshots, overwrite/force behavior, or the role of avatar/fileName, leaving important behavioral gaps for a 9-parameter write 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 short sentences with no filler. The core action and the critical confirm requirement are placed up front, making the tool easy to scan.

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

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

For a tool with 9 parameters, 0% schema coverage, no annotations, and no output schema, the description only explains the basic action and one parameter. An agent cannot safely construct calls involving force, asJson, snapshotLabel, or fileName without additional external knowledge.

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 0% and the description only clarifies 'confirm' and the set/unset intent. The roles of force, value, asJson, avatar, fileName, and snapshotLabel are left entirely unexplained, so the description fails to compensate for the undocumented schema.

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

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

The description opens with a specific action, 'Set or unset', and names the exact resource: 'a local slash/macro variable stored in a specific chat's chat_metadata.variables'. This clearly distinguishes it from the sibling st.variables.set, which appears to be the non-chat-scoped variant.

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

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

It provides a clear operational requirement ('Requires confirm: true') and implies the tool is scoped to chat-local variables. However, it never explicitly says when to prefer this over st.variables.set or st.chat.metadata.patch, nor does it state when not to use it.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool mutates chat_metadata.world_info and requires confirmation, which is useful. It does not explain side effects, reversibility, or how parameters like force, unset, or snapshotLabel affect 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 very brief, front-loads the core purpose, and includes only the most essential requirement. Every word contributes meaning, with no filler or redundant schema 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 7 parameters, no schema descriptions, no annotations, and no output schema, a single sentence is insufficient for an agent to call this tool correctly. The agent is left guessing how to specify the worldbook, which chat, and how to choose bind versus unbind.

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 0%, so the description must compensate, but it only mentions confirm: true. It does not explain the meaning or roles of avatar, fileName, book, force, unset, or snapshotLabel, leaving critical parameter semantics undocumented.

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 action ('Bind or unbind'), a specific resource ('a worldbook'), and the target mechanism ('through chat_metadata.world_info'). This clearly distinguishes the tool from worldbook management tools like st.worldbook.create_empty and generic chat metadata tools like st.chat.metadata.patch.

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 communicates the essential precondition 'Requires confirm: true,' which is important for invocation. However, it does not explicitly state when to prefer this tool over alternatives, when not to use it, or how the bind versus unbind behavior is selected.

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 disclosure burden. It conveys that the operation is read-only and reads parsed config, which is useful, but it does not explain what happens when a path is missing, how the default value is applied, or what the response structure looks like. These are clear gaps but not contradictions.

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

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

The description is a single sentence with no filler and front-loads the core action. The clause 'with default value and code usage hints' is compact but slightly ambiguous, so it is efficient yet not perfectly clear.

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 tool with two flat parameters, the description gives enough to attempt a read operation, but with no annotations and no output schema it should say more about return behavior, path syntax, and the includeDefault effect. It is adequate but leaves meaningful gaps for an agent deciding how to invoke it.

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 0%, so the description must compensate for documenting the two parameters. It alludes to 'dotted config path' for path and 'default value' for includeDefault, but it never explicitly defines the boolean parameter or clarifies whether the default is an input fallback or an output-inclusion flag. This is only partial compensation.

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 action ('Read parsed config.yaml or one dotted config path') and resource, which distinguishes it from sibling tools like st.config.patch (a write operation) and st.config_locations (locations, not values). The phrase 'with default value and code usage hints' adds useful scope but is slightly vague, preventing a 5.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as st.config.patch or st.config_locations. The 'Read' verb implies a read-only use case, but no conditions, exclusions, or related-tool routing are provided.

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 disclosing behavior. 'Map' implies a read-only lookup, but the description does not state that it is read-only, what the return format looks like, or whether it has side effects. This is a significant gap for a tool with no annotation help.

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 or redundancy. It states the action and the target concisely.

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 and no annotations, the description is the sole source of context. It tells what the tool maps, but not the shape of the returned mapping or how to interpret 'semaints tools,' leaving the agent with an incomplete expectation of the result.

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

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

The tool takes zero parameters, so there is nothing for the description to add beyond the empty input schema. The baseline of 4 applies because parameter semantics are not applicable.

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 ('Map') and identifies a clear resource ('high-level SillyTavern configuration domains') mapped to 'real storage locations and semantic tools.' This distinguishes it from siblings like st.config.get and st.config.patch, though 'semantic tools' remains vague.

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 mapping framing implies the tool is for looking up where configuration domains live or which semantic tool applies, but there is no explicit when-to-use statement, no exclusions, and no mention of alternatives. Usage is inferred rather than stated.

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 and does disclose important side effects: the operation mutates config.yaml, requires explicit confirmation and a prior snapshot, and usually requires a restart. The 'usually' phrasing is somewhat vague, but this is substantially more transparent than typical tool descriptions.

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 compact sentence with no fluff. It front-loads what the tool does, then states the critical prerequisites and post-condition.

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?

This is a mutation tool with no annotations and no output schema, so the description should explain parameters, return behavior, and safety details more fully. Five parameters are undocumented, and no information is given about what success or failure looks like, making the description insufficient for safe invocation.

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

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

Schema description coverage is 0%, and the description must compensate. It explains the dotted-path mechanism and confirms the need for confirm:true, but it does not explain key parameters like updates, unset, allowUnknown, or snapshotLabel, leaving the agent to guess their structure and meaning.

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 names the exact resource (config.yaml), the action (Patch), and the method (by dotted paths). This clearly distinguishes it from sibling tools like st.resource.patch and st.config.get.

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 clear preconditions: confirm must be true, snapshots must be taken first, and a restart may be needed. It does not explicitly name alternatives or exclusions, but the context for usage is clear enough.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does disclose that the command is 'controlled' and that confirm must be true, which signals a safety guardrail. However, it does not mention potential side effects, permissions, output behavior, or failure modes for executing commands.

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 brief and front-loaded, with no wasted words. The mandatory confirm requirement is stated clearly. It is slightly redundant with the schema's scope enum, but overall it is an efficient, well-structured description.

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 command-execution tool with no annotations, no output schema, and five parameters, this description is incomplete. It does not explain return values, timeout behavior, how args are passed, what 'controlled' means in practice, or what side effects may result. The minimal information provided leaves significant gaps for an agent.

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 0%, so the description must compensate. It adds meaning only for 'confirm' by stating it is required to be true. The semantics of 'args', 'timeoutMs', and the distinction among the scope values are left entirely to the schema's enum names, which is insufficient for correct invocation.

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 runs a controlled development command and names the three scopes (project-root, st-root, st-mcp). This is enough to identify the tool's core purpose, though it does not explicitly distinguish it from siblings like st.runtime.control or st.source.write.

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

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

The description provides a key precondition ('Requires confirm: true') but gives no guidance on when to use this tool versus alternatives, nor any exclusions. The 'controlled development command' phrasing only weakly implies its intended niche among the many sibling tools.

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

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

With no annotations, the description carries the full behavioral burden. It does communicate that the tool is a check rather than a mutating operation, but it does not define what 'controllable' means or what response/error an agent should expect beyond the bare 'whether' wording.

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, repetition, or extraneous detail. Every word earns its place.

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

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

For a zero-parameter health check the description is usable, but the absence of an output schema and annotations means it should also state the result shape and clarify what 'controllable' means (e.g., reachable, authenticated). It also leaves the relationship to sibling health/verify tools unaddressed.

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 properties, so there are no parameters for the description to document. The zero-parameter baseline of 4 applies, and the description's focus on the target runtime is consistent.

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 'Check' against the resource 'target SillyTavern runtime' and clearly states the tool tests controllability, so it is not a tautology. However, it does not explicitly distinguish itself from similar diagnostic/control siblings such as st.verify or st.runtime.control.

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

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

No guidance is provided about when to run this check versus alternatives like st.verify or st.runtime.control. The pre-flight use case is only implied by the word 'controllable,' leaving an agent without explicit decision criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does add a meaningful behavioral requirement ('Requires confirm: true') that is not obvious from the schema alone. However, it does not disclose the mutating nature of the operation, whether settings are merged or replaced, what happens when the extension does not exist (despite an allowCreate parameter), or any side effects such as snapshots or reloads.

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 short sentences with no filler; the core action is front-loaded and the critical confirm requirement is stated immediately after. It is efficient, though brevity comes at the cost of omitting important parameter context.

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?

This is a complex tool with 8 parameters, nested objects, no output schema, and zero annotations, yet the description explains little beyond the surface action. An agent cannot correctly determine what unset does, how updates should be structured, what configKey selects, what allowCreate or snapshotLabel mean, or what the confirm flag actually gates. The description is inadequate for safe invocation of a tool with this many moving parts.

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 0%, so the description must compensate, but it only covers two conceptual areas: extension_settings (likely updates/configKey) and enabled state (enabled). Six other parameters (name, unset, confirm, allowCreate, snapshotLabel, and the nested updates object) are left completely unexplained. The description adds minimal meaning beyond the raw parameter names.

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 ('Configure') and a clear resource ('a frontend extension'), and it names the mechanism ('through extension_settings and/or enabled state'). This helps distinguish it from siblings like st.extension.install and st.extension.set_enabled, though it doesn't explicitly call them out. It is clear enough that an agent knows what resource this acts on.

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 that this tool is for configuring frontend extension settings or enabling state, which gives some context. The statement 'Requires confirm: true' is a genuine usage prerequisite. However, there is no explicit guidance about when to prefer this over siblings such as st.extension.set_enabled, st.config.patch, or st.character.configure, and no exclusions are stated.

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 says 'Install' but does not mention side effects such as downloading and executing third-party code, persistence, runtime impact, or whether the operation is reversible. The endpoint reference hints at the mechanism but not the consequences.

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 sentence with no filler, front-loaded with the action and resource, then specifying the method. It earns its place and leaves out only information that belongs in other dimensions.

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 mutating tool with four parameters, no annotations, and no output schema, the description is too thin. It does not explain the optional parameters, installation behavior, or what happens after a successful or failed install. An agent could guess the required URL but would not know the effect of `branch`, `global`, or `confirm`.

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 0%, so the description must compensate. It adds 'Git URL' to clarify the `url` parameter, but the optional parameters `branch`, `global`, and `confirm` are completely unexplained. An agent cannot determine what these flags control without external knowledge.

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 ('Install'), a specific resource ('SillyTavern frontend extension'), and the method ('from a Git URL via the ST extension endpoint'). This clearly distinguishes it from sibling tools like st.extension.configure, st.extension.set_enabled, st.extension.registry, and st.plugin.install.

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 frames the use case: installing a frontend extension from a Git URL. It does not explicitly state when not to use it or name alternatives, but the scenario is specific enough that an agent can infer when this tool applies.

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 itself must convey behavior. 'List' implies a read-only operation, and the description states what data is surfaced. However, it does not disclose anything about discovery behavior, failure modes, or whether any side effects occur, leaving some behavioral ambiguity.

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, focused sentence that front-loads the action and resource, then lists the specific information returned. Every phrase 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?

With no output schema and no annotations, the description adequately names the return payload: enabled state, inferred extension_settings config keys, and current config. It is complete enough for an agent to understand what the tool provides, though it could add a note about error or edge-case behavior.

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

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

The tool has zero parameters and the schema coverage is effectively 100% since no inputs are required. Per the baseline for parameterless tools, the description does not need to compensate, and it adds no irrelevant information.

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 ('List') with a clear resource ('discovered frontend extensions') and outlines the exact fields returned. It clearly differentiates from siblings like st.extension.install or st.extension.set_enabled by indicating this is a read-only registry inspection rather than a mutation.

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 verb 'List' implies this is the tool to use for inspecting discovered frontend extensions, but the description does not explicitly state when to prefer it over alternatives like st.plugin.registry or st.extension.configure. Usage context is implied, not spelled out.

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 the core state-changing behavior and adds the prerequisite that confirm must be true, but it does not explain side effects, persistence, or what happens when confirm is missing or false.

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. Every word contributes: the action, the resource, the scope, and the confirmation requirement.

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 three-parameter setter, the description covers the core operation and the notable confirm requirement. However, it lacks any mention of how to obtain the extension name, the return value, or the outcome when confirm is false, leaving some gaps given the absence of annotations and output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies the confirm parameter constraint but does not elaborate on name or enabled beyond what their names imply. 'Enable or disable' indirectly maps to the enabled boolean, providing partial semantic value.

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 action — enable or disable — on a specific resource: a SillyTavern frontend extension. The qualifier 'discovered' helps distinguish it from installation/registry tools among siblings, and the resource type differentiates it from other set_enabled 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?

The description implies usage on already-discovered extensions and instructs that confirm must be true, but it does not explicitly name alternatives or state when not to use this tool. The guidance is present by implication rather than explicit comparison.

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 disclosure burden. It discloses that the operation regenerates/rewrites an existing index and requires an explicit confirmation flag. It does not mention side effects, duration, failure behavior, or whether the operation is destructive beyond the implied regeneration.

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?

One tight sentence front-loads the verb and resource, then immediately states the safety requirement. There is no filler or repetition; every word 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 tool with a single boolean parameter and no output schema, the description covers the core needs: what is regenerated, which features consume the index, and what value must be passed. It omits return value and the effect of confirm:false, but those are minor for a simple refresh operation. A slightly richer description could mention side effects, but this is adequate.

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 0%, but the description compensates by stating the critical constraint on the only parameter: confirm must be true. This is essential information that the schema omits. It does not explain what confirm:false does, but the parameter is simple and its purpose is made clear.

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

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

The description states a specific verb ('Regenerate') and resource ('static upstream ST codebase index'), and names the endpoints that rely on it (st://index, st://index/markdown). This clearly distinguishes it from sibling tools like st.source.read or st.source.write, which operate on source content rather than the generated index.

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: this tool is for rebuilding the index used by st://index and st://index/markdown. It also provides an explicit invocation condition ('Requires confirm: true'). However, it does not discuss alternatives or when not to use the tool, 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?

With no annotations, the description carries the full burden of behavioral disclosure. The verb 'Inspect' reasonably implies a read-only operation and the location is specified, but it does not state return behavior, failure modes, or explicitly confirm no 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 a single sentence that is concise, front-loaded with the action, and contains no redundant information. It earns its place by identifying both the resource and its precise location.

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

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

The tool is domain-specific (MVU runtime state), has no annotations, no output schema, and two undocumented required parameters. The description does not explain what the returned snapshot looks like, how avatar/fileName are used, or any prerequisites or limitations, so the agent lacks key context 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 description coverage is 0%, so the description must compensate for the undocumented 'avatar' and 'fileName' parameters. It does not explain how these parameters map to the inspection target, leaving the agent to infer their meaning from the tool name and schema alone.

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 ('Inspect'), the resource ('MVU runtime variable snapshots'), and the storage location ('chat message variables[].stat_data'). It distinguishes itself from mutating siblings like st.mvu.chat_state.patch.

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 explains what the tool inspects but gives no guidance on when to choose it over alternatives such as st.chat.inspect, st.mvu.settings.get, or st.mvu.entries. No explicit when-to-use or exclusion criteria are provided.

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

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

With no annotations provided, the description carries the full burden. It does disclose a nontrivial behavioral requirement (`Requires confirm: true`) and a defaulting behavior, which is useful. Still, it does not explain what the patch mutates, whether changes are reversible, how `unset` vs `updates` interact, or what happens on failure, leaving several operational traits hidden.

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

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

The description is a single sentence with no filler or repetition. The most decision-relevant facts—action, target, default behavior, and confirmation requirement—are front-loaded and concise.

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

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

Given eight parameters, a nested `updates` object, no output schema, and no annotations, the description is far too minimal. It leaves required parameters, mutation semantics, confirmation flow, and result behavior undefined, so an agent would struggle to invoke this tool confidently without external knowledge.

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 0%, so the description must compensate for eight undocumented parameters, but it only touches on `index` ('defaulting to the latest message') and `confirm`. Required parameters `avatar` and `fileName` are completely unexplained, and nested `updates` / `unset` semantics are absent. This is a significant gap for selecting and invoking the tool correctly.

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 names a specific verb ('Patch'), a specific resource ('MVU runtime stat_data'), and a concrete unit of work ('one chat message'). It also adds a meaningful default behavior ('defaulting to the latest message') that distinguishes the tool from generic patch tools. No ambiguity remains about what this 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?

It clearly states the default target (latest message) and the critical precondition that `confirm: true` is required. However, it does not explicitly explain when to use this tool over siblings like `st.chat.message.edit` or `st.mvu.chat_state.inspect`, so it misses the 'when-not/alternatives' level.

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 'List' verb signals a read-only operation, and the mention of the exact disable/enabled storage field reveals what the output emphasizes. It does not disclose whether permissions or state changes are involved, but for a list tool the main behavioral trait is reasonably conveyed.

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?

One short sentence with no filler; the purpose and scope are front-loaded. The phrase 'exact disable/enabled storage field' is slightly awkward but adds substantive detail without bloat.

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 two undocumented optional parameters and no output schema, yet the description only explains the general purpose and one output attribute. An agent cannot infer what 'book' or 'includeContent' mean or what the returned data structure is, so the definition is too sparse for reliable 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?

The input schema offers no descriptions for 'book' or 'includeContent', and the description does not reference either parameter. At 0% schema coverage, the description leaves the agent with no information about what values to pass.

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 verb 'List' plus the resource 'MVU-related worldbook entries' states exactly what the tool returns, and the qualifier 'MVU-related' distinguishes it from the general st.worldbook.entries sibling. The additional detail about the disable/enabled storage field pins down the output's distinguishing value.

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

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

No explicit when-to-use or alternatives are given. The MVU-related qualifier implies this is the tool for inspecting MVU-specific entry flags, but the description does not tell the agent when to prefer it over st.worldbook.entries or how it relates to st.mvu.entry.set_enabled.

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 context. It only discloses the confirm:true requirement and does not explain side effects, whether the operation is reversible, what happens to the entry, or how snapshotLabel is involved.

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 short, direct sentences with no wasted words. The core action is front-loaded, and the critical confirm requirement is stated immediately after.

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

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

For a tool with six parameters, no output schema, no annotations, and zero parameter documentation in the schema, the description is too sparse. It does not identify the entry sufficiently, explain the book parameter, or describe return behavior, leaving important gaps 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 description coverage is 0%, so the description must compensate by explaining parameters. It clarifies that confirm must be true and that 'enabled' corresponds to the enable/disable action, but leaves uid, book, comment, and snapshotLabel unexplained. Agents still lack meaning for most parameters.

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 names a specific action—'Enable or disable'—and a clear resource: 'one MVU-related worldbook entry.' This distinguishes it from sibling tools like st.extension.set_enabled and st.worldbook.entry.configure because it targets the MVU worldbook entry's enabled state.

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

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

The verb implies this should be used when toggling the enabled flag on an MVU worldbook entry, and the confirm requirement adds a clear prerequisite. However, there is no explicit guidance about when to choose this over st.worldbook.entry.configure or other sibling tools, so routing is left mostly to inference.

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 of disclosing behavior. It adds one useful behavioral trait: a confirmation requirement. However, it does not explain the effects of configuring settings, whether changes are persisted immediately, whether the operation is atomic, what happens if confirm is false, or any permissions/side effects. For a mutating configuration tool, this is minimal disclosure.

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 short and the core purpose is front-loaded, but the brevity approaches under-specification. Given 12 undocumented parameters, no annotations, and no output schema, this level of conciseness is not 'appropriately sized'; it sacrifices necessary detail.

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

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

This is a complex configuration tool with 12 parameters, nested objects, zero schema description coverage, no annotations, and no output schema. The description only offers a general purpose and a confirm requirement. It is critically incomplete for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0% and the description provides no parameter-level meaning. None of the 12 parameters (apiKey, apiUrl, updates, temperature, etc.) are explained, and 'semantic fields' is too vague to compensate. The agent is left without meaningful guidance on what values to supply.

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 action ('Configure') on a specific resource ('MagVarUpdate/MVU global settings'). The resource name distinguishes it from most siblings and especially from st.mvu.settings.get, which is a read operation. However, 'through semantic fields' is vague and it does not explicitly contrast with other patch/configure sibling 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?

No guidance is given about when to use this tool versus alternatives like st.mvu.settings.get, st.config.patch, or st.resource.patch. The only usage hint is 'Requires confirm: true,' which is a precondition rather than a selection guideline. The description does not state when this tool is appropriate or when a different configure/patch tool should be used.

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 clearly indicates this is a read-only operation and that it reports the exact extension_settings storage path, which is useful behavioral context. It does not detail the exact shape of returned settings, but for a zero-parameter getter this is adequate.

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

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

The description is a single concise sentence that front-loads the operation and resource, then states the distinctive output. Every word contributes value, and there is no filler or repetition of the tool name beyond the necessary MVU reference.

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 zero-parameter read tool with no output schema, the description covers the essential context: what is read, and what is reported. A slightly fuller statement of return shape or usage context would make it completely self-contained, but nothing critical is missing for an agent deciding whether to invoke it.

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

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

The tool has zero parameters and the schema has 100% description coverage by virtue of being empty, so there are no parameter semantics to document. The description appropriately adds no redundant parameter information, matching the baseline for a no-parameter tool.

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, 'Read', names the exact resource, 'MagVarUpdate/MVU global settings', and adds a distinctive output detail, 'report their exact extension_settings storage path'. This clearly sets it apart from generic config readers like st.config.get and from mutators like st.mvu.settings.configure.

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?

There is no guidance on when to choose this tool over alternatives such as st.config.get, st.config_locations, or st.mvu.settings.configure. The read-only purpose is implied by the wording, but no explicit context or exclusions are provided.

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 correctly discloses the key behavioral trait: the tool does not write and is a pre-action planning step. However, it leaves undefined what a 'plan' produces, whether it persists, and what 'controlled' means, so richer behavioral context is absent.

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 short sentences with no fluff. The non-writing constraint and usage timing are front-loaded; every clause carries 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?

The tool has no annotations, no output schema, and an untyped optional 'changes' field, yet the description does not explain what the plan returns, how targetUri/goal are used, or what happens after planning. It provides the right invitation to use it but not enough to invole it correctly in complex cases.

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 0% and the description names none of the parameters (goal, targetUri, changes) or explains how they interrelate. The text does not compensate for the schema's lack of 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 clear verb ('Plan') and resource ('ST change'), and its explicit 'without writing' constraint differentiates it from mutation siblings like st.resource.patch. It does not name a particular alternative tool, so it falls short of full 5.

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

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

'Use this before any destructive or complex action' gives an explicit trigger for when to call the tool. It does not name alternatives or state when not to use it, so it misses the strongest possible 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?

With no annotations, the description discloses the key behavioral trait: the operation requires confirm: true and restart, signaling that this mutates persistent configuration and has side effects. It does not cover permission needs, reversibility, or the effect on existing flags, leaving some behavioral ambiguity.

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; purpose is front-loaded and the critical prerequisite/consequence is in a short second sentence. Every word earns its place.

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

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

For a tool with no annotations and no output schema, the description leaves too much unspecified: the semantics of snapshotLabel, what the enable flags actually do, and what the response looks like after configuration. The confirm/restart caveat is helpful but not enough to make the tool safely invocable by an agent.

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 0%, and the description only clarifies the confirm parameter ('Requires confirm: true'). The other three parameters (snapshotLabel, enableServerPlugins, enableServerPluginsAutoUpdate) receive no explanation, so the description fails to compensate for the schema gap.

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 action ('Configure') and target ('SillyTavern server plugin flags in config.yaml'), clearly separating it from sibling plugin scaffold/install/registry tools. It does not explicitly contrast with generic config-editing siblings like st.config.patch or st.resource.patch, so it falls just short of a 5.

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

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

The target ('server plugin flags in config.yaml') implies when to use, and 'Requires confirm: true and restart' gives an important invocation condition and consequence. However it never states when-not-to-use or names an alternative, so usage guidance is primarily implicit.

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 discloses the confirmation requirement and the target directory, which is useful. However, it does not explain filesystem effects, dependency installation, behavior on existing plugins, or error conditions, so transparency is only partial.

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 short sentences with no filler. It front-loads the core action and then adds the key prerequisite. Every word earns its place.

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

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

Given five parameters, no annotations, no parameter descriptions, and no output schema, the description is too thin. An agent cannot determine the meaning of name, branch, or installDependencies, what the return value is, or what side effects an installation may have beyond a generic 'install' action.

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 0%, so the description must compensate for the five parameters. It clarifies that url is a Git URL and that confirm must be true, but name, branch, and installDependencies are left undocumented in both the schema and the description. This is insufficient compensation for the complete lack of schema descriptions.

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

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

The description uses a specific verb ('Install'), a specific resource ('SillyTavern server plugin'), a source ('Git URL'), and a destination ('plugins directory'). It clearly differentiates this tool from sibling installers like st.extension.install and st.bridge.install by specifying 'server plugin' and 'Git URL'.

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

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

The description provides clear context for when the tool applies: installing a server plugin from a Git URL into the plugins directory, and it adds the important requirement that confirm must be true. It does not explicitly name alternatives or state when not to use this tool, but the scoping is specific enough for an agent to select it appropriately.

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 clearly signals a non-mutating 'List' operation but adds no caveats about server access, permissions, or output volume. This is adequate but minimal.

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?

One dense sentence front-loads the action and enumerates the exact data returned, with no filler or repetition of the schema.

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

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

For a no-parameter, read-only list operation, the description names the complete scope of what will be returned (runtime state, manifests, config flags). It does not describe output format, but no output schema exists and this is a simple listing 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 tool takes zero parameters and the input schema is empty with 100% coverage, so there is no parameter behavior for the description to clarify. Baseline for 0-parameter tools is 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 uses a specific verb ('List') with a concrete resource ('server plugin runtime state, installed plugin manifests, and server plugin config flags'), and it clearly separates this read-only registry tool from sibling mutation/configure/install tools such as st.plugin.configure and st.plugin.install.

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: call when you need an overview of server plugin state, manifests, or config flags. It does not explicitly address when not to use it or mention alternative registry tools such as st.extension.registry, leaving some selection work 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 discloses the operation type (creates a skeleton), the outcome (loadable plugin), and a meaningful safety precondition (confirm must be true). However, it does not disclose important side effects such as where files are written, whether existing files get overwritten, or whether the operation is reversible.

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 zero waste: the first states the purpose, the second states the critical precondition. The essential information is front-loaded and every word earns its place.

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

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

For a tool with no annotations, no output schema, and 0% parameter description coverage, two sentences are insufficient. The description omits what the tool returns (e.g., path to the scaffolded skeleton), filesystem side effects, and the role of the optional name/description parameters. The confirm:true note is valuable but does not make the definition 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 0%, yet the description meaningfully explains the most behavior-critical parameter: confirm must be true for the tool to proceed. The other parameters (id, name, description) have semantically transparent names and minimal schema constraints, but no additional meaning or format guidance is given beyond their labels, so the description only partially compensates for the coverage gap.

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 ('Create') and a specific resource ('loadable SillyTavern server plugin skeleton'), making the tool's function immediately clear. 'Skeleton' clearly distinguishes it from related plugin siblings like st.plugin.install (installing an existing plugin), st.plugin.configure (configuring one), and st.plugin.registry (listing them).

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?

Usage context is implied: the tool is for generating a new plugin skeleton from scratch, which a competent agent can infer from the name and purpose statement. However, there is no explicit guidance about when to prefer this over alternatives like st.plugin.install or st.plugin.configure, and the only guidance offered ('Requires confirm: true') is an operational constraint rather than a selection criterion.

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

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

With no annotations, the description carries the burden of explaining behavior. It clarifies that the tool inspects dynamic surfaces ('live' settings, 'runtime bridge state') and implies a read-only inspection. However, it does not disclose whether any side effects occur, whether external bridge state access is required, or what happens when runtime state is unavailable.

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, starts with the primary verb, and uses a colon to enumerate the inspected surfaces. Every phrase earns its place, with 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?

For a simple single-parameter tool, the description names the core inspected surfaces and optional runtime state, which is adequate for basic selection. But it leaves key context unstated: what 'indexed seams' are, what the returned data looks like (no output schema exists), and how includeRuntime exactly changes behavior. An agent could call it, but not with full confidence about the result.

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 has 0% description coverage, so the description must compensate. The phrase 'optional runtime bridge state' maps plausibly to the sole boolean parameter includeRuntime and clarifies what 'runtime' refers to. It still does not explicitly state the parameter name or default behavior, but the meaning is reasonably inferable.

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 ('Inspect') and identifies a distinct resource: the 'prompt/context assembly surface.' Listing 'indexed seams, live prompt-related settings, and optional runtime bridge state' narrows the scope and differentiates it from sibling chat/config inspect tools. However, 'indexed seams' is unexplained jargon, which prevents a perfect score.

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

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

No guidance is given about when to use this tool versus alternatives like st.chat.inspect, st.prompt.set_injection, or st.bridge.health. There are no stated prerequisites, exclusions, or conditions that would route an agent to this tool over a sibling.

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 disclosure burden. It does disclose that this is a gated operation requiring confirmation and a prior snapshot, which signals a risky mutation. However, it does not explain side effects, reversibility, permissions, or what actually changes in the runtime state.

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 short, front-loaded with the primary purpose, and contains no filler. Every clause earns its place. However, given the tool's 22-parameter surface, the extreme brevity borders on underspecification rather than tight editing.

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?

This is a high-complexity tool with 22 parameters, nested objects, enums, no output schema, and no annotations. The description only conveys the tool's abstraction level and two preconditions. It does not explain the target values, the updates object structure, parameter relationships, return behavior, or failure modes, so an agent cannot safely 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 0%, so the description must compensate, but it only addresses confirm and the snapshot workflow. The other 20 parameters, including target, updates, role, position, and budget, receive no semantic guidance, leaving the agent with almost no help beyond raw schema names.

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 clear action, 'Change prompt injection semantics,' and adds a meaningful scoping cue: 'without knowing raw ST setting paths.' This distinguishes it from low-level config-patching tools like st.config.patch, even though no sibling is explicitly named.

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 clear context on when to use the high-level tool ('without knowing raw ST setting paths') and states prerequisites ('Requires confirm: true and snapshots first'). It does not enumerate exclusions or explicitly name alternative tools, but the use case and workflow constraints are clear enough for an agent to route the call.

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 does disclose strong side effects (create/update/delete/upsert/delete) and an important precondition ('Requires confirm: true'). However, it does not explain what happens if confirm is omitted, whether operations are transactional, which combinations of parameters are allowed, or what side effects activating or deleting a set may have.

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

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

The description is a single dense sentence with no filler. It front-loads the primary capability (Enable Quick Reply) and compresses the full operation list efficiently. The final 'Requires confirm: true' is useful, though it could be more prominent as a precondition.

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?

This is a complex multi-mode tool with 9 parameters, nested objects, no required fields in the schema, no output schema, and no annotations. The description does not explain which parameters belong to which mode, what combinations are valid, or what a successful call returns. An agent would struggle to construct a correct invocation beyond guessing from the action verbs.

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 0%, so the description must compensate, and it only partially does. The verbs imply roles for set, enabled, activeSet, deleteSet, reply, and deleteReplyLabel, but many parameters remain opaque, including setOptions, snapshotLabel, and the large nested reply object. No parameter relationships or per-mode requirements are explained.

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 names the resource (Quick Reply) and specifies a concrete action list: enable, activate a set, create/update/delete a set, and upsert/delete slash-command quick replies. It is less sharp than a single-verb description because the tool intentionally covers many operations, but it is not vague or tautological and can be distinguished from the read-oriented sibling st.quick_reply.registry.

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?

There is no guidance about when to choose this tool over alternatives, no mention of the sibling registry for listing quick replies, and no exclusions. The only usage hint is 'Requires confirm: true,' which is a precondition rather than a when-to-use guideline.

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 transparency burden. The verb 'List' indicates a read-only operation and the two object types are named, but there is no explicit statement about side effects, return format, or permission requirements. For a simple zero-param list tool this is acceptable 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?

A single sentence that front-loads the action and resource, with no redundant wording. Perfectly sized for the simplicity of the tool.

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 tells the agent what will be listed and has zero parameters, so invocation is straightforward. With no output schema, it would have been slightly better to state whether the result is a flat list or grouped object, but the core expectation is 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?

The input schema has zero properties and 100% schema description coverage, so there are no parameter semantics for the description to clarify. Baseline 4 applies because there is nothing to document.

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 Lists Quick Reply V2 settings and saved slash-command quick reply sets, using a specific verb and resource. It separates this from the configuration sibling st.quick_reply.configure by focusing on listing, though it does not explicitly name any sibling.

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 intended use is implied by the verb 'List' - an agent would invoke this when it needs to inspect quick reply settings. No when-not-to-use conditions or alternative tools are mentioned, leaving the routing to inference.

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 behavioral disclosure. It does add the important confirmation requirement and the fact that the tool is global in scope, but it does not disclose deletion consequences, whether updates overwrite, default action behavior, or permission/persistence details.

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 brief and front-loaded, with two sentences and no filler. It efficiently conveys the main purpose and the critical confirmation requirement, though a bit more structure around parameter usage would improve clarity.

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?

This is a complex 15-parameter mutation tool with no annotations and no output schema, but the description covers only high-level actions and the confirm flag. It lacks essential context about parameter semantics, return values, defaults, and side effects, making it insufficient for an agent to invoke it correctly in nontrivial cases.

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 0%, so the description must compensate for 15 parameters, but it only clarifies confirm: true and loosely describes the action categories. It does not explain findRegex, replaceString, placements, minDepth/maxDepth, runOnEdit, promptOnly, trimStrings, markdownOnly, substituteRegex, or snapshotLabel.

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 names a specific resource (global ST regex script) and a clear set of operations: create, update, enable/disable, delete. This distinguishes it from sibling tools like st.regex.registry and other configure tools without needing to inspect the schema.

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 is the tool to use for managing global regex scripts and gives a hard prerequisite (confirm: true). However, it does not explicitly say when to prefer this over alternatives, mention st.regex.registry for listing, or explain what happens when certain parameters are omitted.

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. 'List' implies a read-only operation and 'global' scopes the resource, but it does not disclose output shape, side effects, or metadata semantics. It adds some context but remains minimal.

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 sentence with no filler, front-loaded with the action and resource. It is appropriately concise, though the phrase 'normalized placement metadata' is dense and could be clearer.

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 listing tool, this is almost enough: the resource and scope are clear. However, with no output schema, the description does not clarify what 'normalized placement metadata' contains or what shape the returned list takes, leaving a meaningful 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?

The tool haseeen 0 parameters and the schema is trivially covered. Description does not describe parameters because none exist, which is acceptable. Baseline of 4 applies for zero-parameter tools.

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 ('List') and a specific resource ('global ST regex scripts'), and mentions the output ('normalized placement metadata'). It is clear enough to distinguish from siblings like st.regex.configure, though it does not explicitly name an alternative.

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 does not provide guidance about when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. The intended use is implied by 'List' but no explicit usage context is given.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does reveal two important traits: confirmation is mandatory and a snapshot is created before writing. This goes beyond the bare schema, though it stays silent on failure modes, rollback, or whether the patch replaces or merges.

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 leads with the action and packs two key behavioral constraints into a compact space. 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?

For a tool with 4 parameters, no output schema, and zero schema descriptions, this description is too sparse. An agent is left to guess what 'supported ST resource' means, what the patch object should look like, what snapshotLabel does, and what happens after the write.

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 0%, so the description must compensate for the parameters. It only addresses 'confirm' by stating it must be true, and leaves 'uri', 'patch', and 'snapshotLabel' without any explanation. Given the schema provides no descriptions, this is a significant gap.

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 clear verb and resource ('Patch a supported ST resource'), so an agent knows it is a write/modify operation on resource state. However, it does not distinguish this generic resource patch from sibling patch tools like st.config.patch or st.mvu.chat_state.patch, so it falls short of full differentiation.

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 no guidance on when to choose this tool over alternatives. It mentions a hard requirement ('Requires confirm: true') but that is a call-time constraint, not a condition for selecting this tool versus another patch or read tool. No sibling tools are referenced.

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 only says 'Read' and gives examples, without describing what the read returns, whether it is purely read-only, whether special permissions are needed, or how errors are surfaced. This is insufficient for a tool with zero annotation support.

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. It opens with the verb and object, gives a concrete example pattern, and wastes no 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 one-parameter read tool, the minimal description is understandable, but with no output schema and no annotations, the agent is left guessing about the return value and the full set of valid 'standard ST resource' URIs. The examples help but do not fully compensate for the 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 schema has a single required uri parameter with a pattern but no description, so schema coverage is low. The description adds meaning by framing the parameter as a 'standard ST resource' URI and providing examples, but it does not enumerate valid resource types or explain the URI structure beyond what the pattern already implies.

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 action ('Read a standard ST resource by URI') and gives concrete examples (st://characters, st://extensions), making the core purpose clear. It does not, however, explicitly distinguish itself from similar sibling tools like st.source.read or various inspect 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?

The description implies the tool is for reading resources addressed by st:// URIs, but provides no explicit guidance on when to use it vs alternatives, no prerequisites, and no exclusions. The URI examples provide only weak contextual signal rather than real routing 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?

No annotations are provided, so the description must disclose behavioral traits itself. 'Restore' implies a mutating, potentially destructive operation, but the description does not state whether it overwrites current state, whether it is reversible, whether confirmation is required, or what side effects occur. The meaning of 'confirmed write operation' also remains unexplained.

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 waste. It is concise and easy to parse, though the ambiguous trailing phrase 'or a confirmed write operation' keeps it from being fully crisp.

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 mutating operation with no annotations, no output schema, and undocumented parameters, the description is seriously underspecified. It conveys the core purpose but does not explain safe invocation, required confirmation steps, or the effect on current state, leaving an agent to guess.

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 0% and the description does not mention 'id' or 'confirm' at all. 'id' could plausibly be a snapshot identifier and 'confirm' a confirmation flag, but the agent gets no guidance on how to use them correctly.

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, 'Restore,' and names the resource it acts on: a snapshot from st.snapshot or a confirmed write operation. This distinguishes it from st.snapshot, which creates snapshots. However, the phrase 'confirmed write operation' is left unefined and confuses the scope somewhat.

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 it should be used when a snapshot or confirmed write needs to be undone, but it does not provide explicit when-to-use or when-not-to-use guidance. No alternatives or exclusions are mentioned beyond the source of the snapshot.

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 disclosure burden. It usefully identifies start/stop/restart as mutating and requires confirm:true, while implicitly treating status as non-mutating. Still, it does not describe side effects, permissions, reversibility, or response behavior, which matters for a runtime control 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 a single front-loaded sentence that immediately states the resource and action set, followed by a concise safety condition. Every clause earns its place, and there is no filler or redundant repetition of the schema.

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

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

For a simple two-parameter command dispatcher, the description covers the required action and the confirm requirement. It does not describe return values or the operational consequences of start/stop/restart, but the low complexity and explicit enum make it largely sufficient for an agent to select and invoke the tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It enumerates the possible action values and gives confirm semantic weight by stating that mutating actions require confirm:true. This goes beyond the raw enum and boolean schema, though it does not explain each action's full effect.

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 clear verb and resource: 'Run configured SillyTavern runtime status/start/stop/restart commands.' The action enum is explicitly enumerated, making the tool's scope obvious. It is distinguishable from the sibling list as the only runtime-control tool, though it does not explicitly name an alternative.

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 runtime status, start, stop, and restart commands, and adds a prerequisite: 'Mutating actions require confirm: true.' However, it does not say when to prefer this tool over related siblings, nor does it provide any when-not-to-use or alternative routing 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?

With no annotations, the description carries the full burden of behavioral disclosure. It indicates the tool writes a filesystem snapshot, but does not disclose where snapshots are stored, whether existing snapshots are overwritten, what permissions are needed, or how to use the snapshot afterward.

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. It is concise and easy to parse, though it achieves this by omitting important context.

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 annotations and no output schema, yet the description does not explain the meaning of the optional 'label', the snapshot storage location, or what the tool returns. An agent has enough to guess the core action, but not enough to invoke it with confidence.

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 0%, and the description never mentions the 'label' parameter. An agent cannot infer whether the label is a snapshot name, a tag, or some other identifier.

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 action ('Create a filesystem snapshot') and identifies the resources covered ('ST config, user data, extension, and plugin paths'). It is clear enough to distinguish st.snapshot from most siblings, though it does not explicitly contrast it with related tools like st.rollback or st.config_locations.

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 no explicit guidance on when to use this tool versus alternatives. It implies a backup purpose, but never says when a snapshot is appropriate, when it isn't, or which sibling tool should be used instead.

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 burden of behavioral disclosure. The phrase 'without leaving that scope' is a meaningful behavioral guarantee about path confinement, which adds real value. However, it does not describe error behavior, file encoding, symlink handling, or the effect of maxBytes, leaving notable gaps.

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 core action and scope restriction. It is efficient and avoids redundancy, though it may be slightly too terse given the parameter documentation gaps.

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?

This tool has 3 parameters, no output schema, and no annotations, so the description needs to be more self-sufficient. It fails to explain the path format, maxBytes semantics, return value, or error conditions, leaving an agent uncertain about correct invocation despite the clear scope constraint.

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 0%, so the description must clarify parameter meaning, but it only repeats the scope enum values already in the schema. It does not explain what 'path' should look like (relative vs absolute), what counts as a source file, or how maxBytes affects the read (e.g., truncation or failure).

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 'Read' and the resource 'source file', and it identifies the three allowed scopes. It distinguishes the tool from write operations like st.source.write, but it does not explicitly contrast it with st.resource.read, which is a close sibling.

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 the tool: to read a source file within project-root, st-root, or st-mcp. It gives the scope context but does not state when NOT to use it or mention alternatives such as st.resource.read, so usage guidance is only implicit.

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 a heavier burden. It does disclose a key behavioral requirement: confirm must be true and snapshots must be taken first. However, it omits other behavioral traits like overwriting behavior, path validation, rollback implications, or return value. It is helpful but incomplete.

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

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

The description is a single sentence with no wasted words. It front-loads the core purpose and then adds the most important prerequisite, making it compact and readable.

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

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

For a tool with no annotations, no output schema, and five parameters, this description is too thin. It does not explain how to take a snapshot, whether the operation overwrites, what path format is expected, or what happens when confirm is false. An agent would need more details to invoke it confidently.

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 0%, so the description must compensate. It adds meaning to 'confirm' by requiring it to be true, and hints at 'snapshotLabel' via 'snapshots first', but it says nothing about 'path' or 'content' beyond their names. The description only partially covers the parameter semantics needed.

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 ('Write'), a resource ('source file'), and the allowed scopes ('project-root, st-root, or st-mcp'). This distinguishes it from siblings like st.source.read and st.resource.patch, so an agent can tell what the tool does at a glance.

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 important procedural context by stating that confirm: true and snapshots are required before writing, but it does not explicitly say when to prefer this tool over alternatives or when not to use it. Usage is implied rather than fully spelled out.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clearly implies a read-only operation and names the underlying storage location, but it does not explain output shape, ordering, or any error/edge-case 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?

A single, compact sentence that front-loads the action and resource. Every word contributes meaning, with no filler or redundant restatement of the tool name.

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 parameterless listing tool, the description provides enough to call it correctly. The absence of an output schema is mitigated by 'List ... variables', which clearly implies the return value, though richer detail about the returned format would be beneficial.

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

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

The tool has zero parameters and the schema is fully covered, so there is nothing for the description to add. The description's mention of scope ('global') clarifies what is being listed, matching the baseline for a parameterless tool.

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 ('List'), a clear resource ('global ST slash/macro variables'), and the storage location. It also distinguishes this read-only registry tool from sibling write/set tools like st.variables.set.

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 intended use is implied by the word 'global' and the listing verb, but there is no explicit guidance about when to choose this tool over alternatives or when not to use it. No exclusions or conditional usage are provided.

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 burcen. It explicitly discloses the mutating nature ('set or unset') and the prerequisite that confirm must be true. It does not explain persistency, reversibility, or side effects of unsetting, which would make it more 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 two short sentences with no filler. The core operation is front-loaded, and the confirmation requirement is stated as a separate actionable note. 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 tool with 6 parameters, no schema descriptions, no output schema, and no annotations, this description is insufficiently complete. It communicates the high-level action and one prerequisite, but leaves multiple parameters and potential side effects unexplained, so an agent will likely need to guess or inspect the schema.

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

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

The schema has 0% description coverage and 6 params, but the description only addresses confirm ('requires confirm: true') and vaguely implies unset behavior. It does not explain value, asJson, snapshotLabel, or the exact role of unset, leaving significant ambiguity for an agent trying to construct a correct call.

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 specific operation ('Set or unset') and the exact resource ('a global ST slash/macro variable'). The word 'global' differentiates this from st.chat.variables.set and st.variables.registry, so an agent can select it appropriately.

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

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

The description provides clear context for when to use the tool: when a global ST slash/macro variable needs to be created or removed. It does not explicitly name alternatives or exclusions, but the global-vs-chat distinction is implicit and sufficient for most routing decisions.

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 behavioral disclosure burden. It does clarify that this is a read-verification check rather than a UX evaluation, which is useful. However, it does not state whether the operation is side-effect free, what happens on failure, or whether the resource must already exist.

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 short sentences with no filler. The core action is front-loaded, and 'not a UX proof' earns its place by preventing a likely misuse. Nothing redundant is present.

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

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

For a tool with no output schema and no annotations, the description should explain what a successful or failed verification returns and how targetUri should be used. It also doesn't connect to the sibling change operations it is presumably meant to follow, such as st.resource.patch. The intent is clear, but operational details are missing.

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

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

Schema description coverage is 0%, and the description never mentions targetUri or explains how to supply the resource being verified. The parameter name alone suggests a URI, but the description adds no semantic meaning beyond the schema's minimal pattern/type information.

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 object: 'Verify that a resource can be read after a change.' This clearly distinguishes it from direct read and patch siblings, and the 'technical check, not UX proof' caveat adds further intent. It does not name sibling alternatives, so it is clear but not maximally 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 states the trigger condition explicitly: use it 'after a change.' It also gives an exclusion: it is a technical check, not a UX proof, which prevents an agent from using it for user-facing validation. It does not name specific alternative tools, but the timing and boundary are clear enough.

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

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

With no annotations, the description carries the full burden, but it only states that the tool creates an empty shell and requires a confirm flag. It does not disclose side effects, whether it can overwrite an existing worldbook, what 'shell' means in terms of state, or what happens if confirm is false. These are material gaps 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?

Two short sentences with no filler. The purpose is front-loaded and the confirm requirement is stated separately. Every word earns its place.

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

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

The tool has four parameters, no annotations, no output schema, and zero schema property descriptions. The description is too thin to let an agent safely invoke it: it does not explain the overwrite behavior, the meaning of snapshotLabel, the naming requirements for 'name', or what a successful creation returns. An agent would need to guess on at least three parameters.

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 0%, so the description must compensate for the 4 parameters. It adds meaning only to 'confirm' by stating it must be true, but leaves 'name', 'overwrite', and 'snapshotLabel' entirely unexplained. This is inadequate given the complete lack of schema descriptions.

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

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

The description uses a specific verb and resource ('Create an empty worldbook shell') and adds a purpose clause ('for later entry management') that separates it from sibling tools that inspect, delete, or configure entries. The 'empty' qualifier distinguishes it from entry-level management 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 phrase 'for later entry management' gives clear context for when to use the tool, and 'Requires confirm: true' is a direct usage requirement. It does not explicitly name alternative tools or when not to use it, but the intended workflow is clear.

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