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

No annotations provided, but the description discloses key behaviors: read-only operation, baseline derivation, field defaults, return structure including truncation. Missing details like authorization or error handling, but sufficient for safe invocation.

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?

Front-loaded with purpose and key behavior. Structured Args and Returns. Slight redundancy in explanatory sentences but overall efficient.

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

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

Given no output schema, the description fully explains the return dict and all modes of use. Covers both analysis and live inventory, baseline derivation, and default fields.

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%, yet the 'Args' section fully describes each parameter's purpose, behavior when omitted, and provides an example. Adds significant meaning beyond the schema.

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

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

The description clearly states it reports endpoints drifted from a per-field baseline, with a specific verb 'Report' and resource 'endpoints drifted'. It answers the question 'which endpoints have drifted from the fleet?' and distinguishes from siblings by focusing on drift analysis vs other endpoint 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?

Explicitly explains when to use 'endpoints' vs 'target', and that omitting 'baseline' derives fleet majority. No explicit exclusions stated, but the context is clear and actionable.

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

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

With no annotations, the description fully discloses the write nature, high risk, reversibility, and the fact that prior profile is captured for undo and audit trail. This provides substantial behavioral context beyond the basic action, though it could still mention potential side effects or failure modes.

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

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

The description is concise and well-structured: a one-line summary then a clear Args block. Every sentence provides value without verbosity, making it easy for an agent 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 tool with 3 parameters and no output schema, the description adequately covers the action, impact (reversible, audit trail), and parameter usage. It does not mention success responses or error states, but the description is sufficient for a typical assignment operation.

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 description includes an Args section explaining each parameter: endpoint_id as 'as returned by endpoint_list', profile_id as 'Config profile to assign', and target as 'Endpoint-management target name from config; omit for the default.' Since the schema has 0% description coverage, this adds crucial meaning that aids agent invocation, though some explanations are minimal.

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

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

The description starts with 'Assign a config profile to an endpoint (reversible)', which clearly states the action and resource. The additional detail about capturing prior profile and providing undo further clarifies the tool's specific function, distinguishing it from sibling tools like endpoint_get or endpoint_list.

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

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

No explicit guidance on when to use this tool versus alternatives. While it mentions the undo and audit trail, it does not specify contexts where assignment is appropriate or when to prefer other tools. The absence of usage scenarios or prerequisites limits the agent's decision-making.

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 fully disclose behavior. It mentions it is a READ operation and returns a normalized shape, but omits details about error handling (e.g., not found), authentication requirements, rate limits, or any side effects.

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

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

The description is concise with a clear label ([READ]) and structured argument list. No redundant information, though it could be slightly tighter.

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

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

The tool is simple (single endpoint retrieval), but the description lacks details about the output shape beyond 'normalised stable shape'. No output schema is provided, so more detail on the return format would improve completeness.

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?

With 0% schema description coverage, the description adds meaningful context for both parameters: endpoint_id is the id from endpoint_list (including uuid/mac), and target is an optional config name. This clarifies usage beyond the schema's type-only definition.

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

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

The description clearly states the tool retrieves one managed endpoint by id and normalizes it. It distinguishes implicitly from endpoint_list (list vs. single) but does not explicitly differentiate from other 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 indicates that the endpoint_id comes from endpoint_list and that target can be omitted for the default. However, it does not specify when to use this tool vs. alternatives like endpoint_assign_profile or session_list.

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

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

With no annotations, the description fully discloses behavior: it is a read operation that works on injected data, deduces baselines from fleet majority if baseline is omitted, and cites deductions in reasons. All behavioral traits are 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 well-structured with a summary, detailed explanation, Args section, return format, and example. It is slightly verbose but every part adds value. The structure is clear and front-loaded.

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

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

Despite having no output schema, the description fully specifies the return dict structure (endpointsEvaluated, baseline, summary, worst) and notes the note field. For a tool with moderate complexity and no annotations, the description covers all necessary details.

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 0% description coverage, but the description compensates by explaining each parameter: endpoints are required injected rows, stale_hours has a default of 24, and baseline is an optional object with defaults derived from the fleet. This adds crucial meaning beyond the schema.

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

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

The description clearly states it computes a composite per-endpoint health score (0-100), sorting worst first. It addresses a specific need ('which endpoints are worst?') and distinguishes from sibling tools like endpoint_list (which lists endpoints but does not 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?

The description explains that the tool analyzes injected inventory rows and does not connect live, implying it should be used after fetching data via endpoint_list. It does not explicitly mention when not to use or contrast with alternatives like patch_compliance, but the context is clear.

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

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

The [READ] prefix indicates a non-destructive read operation, which is valuable given no annotations are provided. However, the description lacks details on authentication, rate limits, or any potential side effects, though for a simple list these are likely 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?

The description is concise with two clear sections: a summary line and an Args list. Every sentence provides value; no redundancy.

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

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

Given the tool's simplicity (one optional parameter, no output schema), the description covers the key aspects: what the tool returns, that it is a read operation, and the parameter's purpose. It could mention pagination or endpoint count limits but is complete enough for a basic list tool.

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

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

Schema coverage is 0%, so the description must compensate. The Args section explains the 'target' parameter as 'Endpoint-management target name from config; omit for the default', adding meaningful context beyond the schema's type info.

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 'List all managed endpoints' with a [READ] prefix, specifying the verb and resource. It lists the fields returned (id, hostname, OS, agent/patch, online), which distinguishes it from sibling tools like endpoint_get (single endpoint) or drift_report (report).

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 does not provide explicit guidance on when to use this tool versus alternatives like endpoint_get or patch_status. There is no mention of context or exclusions, leaving the agent to infer usage from the tool name and siblings.

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 provided, so the description carries full burden. It discloses write operation, medium risk, no safe inverse, records prior state, and irrevocability, providing good behavioral context.

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 plus Args list, front-loaded with risk annotation. Every sentence adds value with no 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?

Covers core purpose, risk, parameter explanations. Lacks return value or result description, but for a simple write tool with no output schema, it is fairly 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%, but the description adds brief explanations for both parameters (endpoint_id and target), clarifying source and default behavior. Could be more detailed.

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 'Request an endpoint reboot' and resource 'endpoint', with a risk annotation. It distinguishes itself from sibling tools like endpoint_list or endpoint_get by being a write action.

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

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

The description implies use for rebooting endpoints but does not explicitly state when to use vs alternatives or when not to use. The note about no undo provides some behavioral 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?

No annotations are provided, so the description carries full burden. It clearly marks the tool as READ by starting with '[READ]'. It describes what the tool does (detects storms, flags slow sessions) and what it returns (dict with fields). It does not mention any destructive side effects, and no contradictions arise.

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

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

The description is well-structured with a concise opening line, a guiding question, parameter list, return value description, and example. It is front-loaded with key purpose. Slightly verbose but every sentence adds value for a complex 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?

Given the complexity (7 params, no output schema, 0% schema coverage), the description is complete. It covers purpose, parameter semantics, return structure, and provides an example. The agent can fully understand how to invoke and interpret 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%, but the description provides thorough parameter explanations for all 7 parameters, including defaults (e.g., 'default 24'), units (ms, s), and behavior (e.g., 'Pass sessions for pure analysis'). This adds significant meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Detect login storms + rank the slowest login/boot contributors.' It specifies the action (detect and rank) and the resource (login storms and slow contributors), and distinguishes it from sibling tools like 'session_list' or 'endpoint_list' by focusing on storm analysis.

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

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

The description provides explicit context for when to use: 'Answers is this a morning login storm...' It also gives guidance on input options: 'Pass sessions for pure analysis, or a target to pull live via session_list.' However, it does not explicitly state when NOT to use or name alternative tools for different scenarios.

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 full burden. It clearly labels the tool as '[READ]' (read-only), describes what it returns (fleet health statuses), and explains the parameter. However, it lacks details on authentication needs, rate limits, or whether the data is cached or real-time, which would be helpful for full transparency.

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

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

The description is concise and well-structured. The first sentence front-loads the core purpose, and the second paragraph provides usage guidance and parameter details. No wasted words; every sentence adds value.

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

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

Given the tool's simplicity (one optional parameter) and no output schema, the description provides adequate context: what it does, when to use, and parameter semantics. However, it could be improved by briefly describing the output format or any limitations, but overall it's sufficiently complete for an agent to use correctly.

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

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

The input schema has zero description coverage for the 'target' parameter. The description compensates fully by explaining the parameter's meaning ('Endpoint-management target name from config') and usage ('omit for the default'), adding significant value beyond the schema.

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

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

The description clearly states the tool's purpose with specific verb 'READ' and resource 'fleet health', listing included elements (online/offline, stale endpoints, version spread). It distinguishes from siblings by advising to call this first before drilling into specific tools like endpoint, login storm, or drift report.

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

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

The description explicitly states when to use ('Call this first to triage a managed-endpoint fleet') and implies when not to (before drilling into specific endpoint, login storm, or drift report). It names alternative tools that provide more detailed views.

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

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

With no annotations, the description fully discloses behavioral traits: read-only operation, exact string match for compliance (not version semantics), injected-only data, return fields, and defaults. No side effects or hidden behaviors are omitted.

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

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

The description is well-structured with summary, details, parameter docs, return dict, and example. It is slightly verbose but each sentence adds value. Could be slightly more concise, but overall efficient.

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

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

Given no output schema and only 3 parameters, the description adequately covers input, algorithm, output fields, and an example. It lacks error handling or edge cases, but for a compliance tool it is sufficiently complete.

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

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

Schema coverage is 0%, but the description provides detailed parameter explanations: endpoints as injected inventory, target_patch with fleet-majority default, and sla_pct with 95.0 default. An example further clarifies usage, adding significant value beyond the bare schema.

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

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

The description clearly states the tool's purpose: computing patch-compliance SLA as a percentage of the fleet on target patch level, with a verdict and non-compliant list. It distinguishes from patch_status by reframing it as a compliance metric, and specifies it is injected-only and not a live collection.

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 SLA compliance analysis but does not explicitly contrast with sibling tools like drift_report or patch_status. It notes injected endpoints are required, but does not provide explicit when-to-use or when-not-to-use 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?

Annotated as [READ], the description clearly indicates read-only behavior. It does not mention performance or authentication, but for a read operation this is acceptable.

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

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

The description is concise, front-loaded with purpose, and structured with Args and Returns sections. Every sentence adds value without redundancy.

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

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

Despite no output schema, the description specifies the return dict keys. However, it lacks explanation of 'truncated' and the structure of 'behind[]' items, leaving minor gaps.

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

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

With 0% schema coverage, the description fully compensates by explaining all three parameters: target_patch (desired patch level), endpoints (injected inventory), target (endpoint-management target name).

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 returns patch-level distribution and behind endpoints, using specific resource 'patch status' and action 'read'. It distinguishes from siblings like endpoint_get and drift_report.

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 parameter behaviors (target_patch defaults to fleet-majority, endpoints skips live collection, target defaults) but does not explicitly state when to use this tool over alternatives.

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

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

With no annotations, the description carries full burden. The [READ] prefix indicates read-only, but it does not disclose details like pagination, sorting, error handling, or behavior when parameters are invalid. This is adequate for a simple tool but could be 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 extremely concise, front-loaded with the purpose, and uses bullet points for arguments. Every sentence provides value without redundancy, making it efficient 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?

Given the tool's simplicity (2 parameters, no output schema, no annotations), the description covers purpose, return fields, and parameter details. While it lacks sorting or pagination info, it is largely complete for its complexity.

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

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

Schema coverage is 0%, but the description compensates well: it explains since_hours (range 1..720, default 24) and target (endpoint-management target name from config; omit for default). This adds meaningful context beyond the schema's type and default.

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 reads recent login/boot sessions and lists the fields returned (endpoint, user, login_ms, boot_ms, result). This distinguishes it from sibling tools like endpoint_list, which lists endpoints, making its purpose specific and unambiguous.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention conditions, prerequisites, or scenarios where other siblings would be more appropriate, leaving the agent to infer 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?

No annotations provided, but the description discloses that the inverse tool runs through its own governed tool, enforcing risk tier and approver requirements. It also explains dry_run behavior and the single-use constraint.

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

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

The description is well-structured with a title line and explanation, sentences are informative, and it is appropriately sized. Minor room for tighter wording but overall good.

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?

No output schema, so return values are not described. It covers main behavioral aspects but does not mention error cases or what happens if undo_id is invalid. Adequate but could be more complete.

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

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

Schema coverage is 0%, but the description adds meaning: undo_id comes from undo_list or _undo_id, dry_run previews without executing, target passes through to inverse tool when accepted.

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

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

The description clearly states it 'applies a recorded undo by dispatching its inverse tool', specifying the action and the resource (undo). It distinguishes from siblings, especially 'undo_list'.

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 when to use: to apply an undo. It mentions dry_run for preview and that a token can only be applied once. It does not explicitly state when not to use or alternatives, but the context is clear.

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

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

The description starts with '[READ]', indicating it is a non-destructive read operation. It discloses that the target parameter is unused, which is a behavioral detail beyond the schema. Since no annotations are provided, the description adequately covers basic behavioral traits, though it omits potential side effects or limitations.

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 concise: it front-loads the purpose in the first sentence, then describes the output format, and finally explains the parameters. Every sentence adds value, and there is no unnecessary text.

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

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

The description covers the key aspects of the tool: it lists not-yet-applied tokens, orders them most recent first, and includes the necessary fields (original tool, inverse tool, human note, and undoId). It mentions the use of undoId with undo_apply. Without an output schema, this provides sufficient context for an agent to understand and use the tool, though it could briefly mention the return format or pagination.

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 description explains both parameters beyond the schema: limit as 'Max rows to return (default 50)' and target as 'Unused (undo state is host-local); accepted for CLI uniformity.' Since schema description coverage is 0%, this adds critical meaning, especially clarifying that target is effectively ignored.

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 clearly that the tool lists not-yet-applied undo tokens in reverse chronological order. It specifies that each entry includes the original tool, inverse tool, and human note. This distinguishes it from the sibling tool undo_apply, which applies an undo token.

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 that the undoId returned should be used with undo_apply, providing clear context for when to use this tool (before applying an undo). It does not explicitly list when not to use it, but the usage context is well-defined.

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