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

No annotations are provided, so the description carries the full burden. It discloses the read-only nature with '[READ]', explains the baseline derivation behavior when no baseline is provided (fleet majority), and details truncation semantics with the 'truncated' flag and guidance to re-run with a higher limit. This is thorough behavioral 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 well-structured with a clear lead-in, a succinct answer to the core question, and a bulleted argument list. It includes a concise example. Every sentence adds value; there is no fluff. It is appropriately sized for the tool's complexity.

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

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

The description provides the return dict structure, explains the meaning of 'driftedCount' vs 'truncated', and gives a concrete example. It covers all necessary details for an agent to invoke the tool correctly, including the optional baseline derivation and the endpoints/target alternatives. Nothing essential is missing.

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

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

Schema description coverage is 0%, so the description must compensate. It does so comprehensively: each parameter (baseline, fields, endpoints, target, limit) is explained with its purpose and default behavior, going beyond the schema's type/default information. For example, it clarifies that omitting baseline derives fleet majority and that endpoints skips live collection.

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

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

The description clearly states the tool's function: 'Report endpoints drifted from a per-field baseline.' It uses a specific verb and resource, and it distinguishes itself from sibling tools like overview or patch_compliance by focusing on drift analysis. The '[READ]' prefix further clarifies its nature.

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 it: 'Answers which endpoints have drifted from the fleet?' and provides guidance on using 'endpoints' for pure analysis vs 'target' for live inventory. It doesn't explicitly name alternative tools or exclusion conditions, but the context is clear enough for an agent to decide when to invoke it.

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

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

No annotations are present, but the description supplies the safety profile itself: it is a write, high risk, reversible, captures the prior profile for an undo and audit trail, and dry-run resolves the same path and before-state while refusing on the same grounds as the real call. This is exceptionally 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 front-loaded with the [WRITE][risk=high] tag and a one-line summary, followed by a tight dry-run explanation and a concise Args block. Every sentence adds useful information without 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 high-risk write tool with no annotations and no output schema, the description covers behavior, reversibility, undo/audit trail, dry-run behavior, and argument provenance. It is slightly incomplete in not describing the success response or explicit error conditions beyond the dry-run refusal scenario.

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 Args section fully compensates for all four parameters. It explains dry_run semantics, endpoint_id provenance via endpoint_list, the meaning of profile_id, and the target source/config default behavior beyond what the schema states.

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 opening line names a specific action (assign), the resource (config profile), and the destination (endpoint), and marks it as a write/reversible operation. This makes it immediately distinguishable from sibling read tools like endpoint_get and maintenance actions like endpoint_reboot.

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 operational guidance for using dry_run=True as a preview versus the real write, and explains that endpoint_id comes from endpoint_list and target can be omitted for the default. It does not explicitly name alternatives such as undo_apply or state when not to use this tool, so it misses the top anchor of 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?

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 provided, the description carries the full behavioral burden. It discloses that the tool is read-only, uses no live connection, deducts points for specific risk signals, cites deductions in 'reasons', derives baselines by fleet majority when none is given, and describes truncation behavior. This is exceptionally transparent 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 structured with a summary, Args, Returns, and an Example. Every section adds necessary information: scoring logic, parameter semantics, output shape, and truncation guidance. There is minor redundancy about 'no live connection', but overall it is dense and purposeful rather than padded.

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 4-parameter tool with no output schema and no annotations, the description is remarkably complete. It covers all parameter meanings, the scoring model, baseline derivation, return structure, and a practical edge case (truncation). The presence of an output shape description compensates fully for the missing 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 fully document parameters. It does: 'endpoints' is described with its expected shape, 'stale_hours' has a threshold definition and default, 'baseline' is explained with its intended object shape and fallback, and 'limit' has a default and behavioral meaning. The example further clarifies real usage.

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 '[READ] Composite per-endpoint health score (0-100), worst endpoints first' and explicitly answers 'which endpoints are worst?'. This is a specific verb, resource, and ranking behavior. It also distinguishes itself from siblings by stating it analyzes injected inventory rows rather than using a live connection.

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 states when to use it: when you want a ranked health score over already-injected endpoint inventory rows, and it notes no live connection is used. It also explains baseline fallback behavior. It does not explicitly name alternative tools or say when not to use it, but the context is strong enough to guide selection.

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

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

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?

With no annotations, the description carries the full burden. It discloses key behaviors: the operation is irreversible ('no safe inverse'), records prior online state for audit, and offers a dry_run preview. This is substantial, though it does not detail permissions, side effects on the endpoint, or failure behavior. Still, it is transparent about the most critical aspects.

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 front-loaded purpose, followed by explanatory context and a clear Args list. It is slightly verbose due to the contextual explanation, but every sentence adds value. The bracket notation [WRITE][risk=medium] is unconventional but informative. Overall, it is appropriately sized and organized.

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, no annotations, and three parameters, the description covers purpose, usage, parameter meanings, and irreversibility. It references endpoint_list for ID acquisition, which aids integration. It does not describe return values or failure modes, but for a request-type tool this is a minor gap. The description is sufficient for an agent to invoke it correctly.

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

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

Schema coverage is 0%, so the description must compensate. It does so comprehensively: each parameter is explained in the Args section (endpoint_id from endpoint_list, dry_run for preview, target from config with default). This adds meaning far beyond the bare schema types and defaults.

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: 'Request an endpoint reboot'. The verb and resource are specific and unambiguous. However, it does not explicitly differentiate from sibling tools (e.g., endpoint_get, endpoint_assign_profile) beyond the action itself, so it lacks the explicit sibling distinction seen in top-tier examples.

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

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

The description provides clear context on when to use the dry_run parameter (preview before committing) and references endpoint_list for obtaining the endpoint_id. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions. It implies usage but doesn't offer explicit when-not 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, the description carries the full behavioral burden. It declares '[READ]', explains that every flag is reported as a number rather than a verdict, describes storm grouping semantics, threshold behavior, truncation envelopes, and when live collection is skipped. This gives an agent a reliable model of what the tool does and does not do.

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

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

The description is front-loaded with a summary, then organized into Args, Returns, and Example sections. Every sentence provides necessary information about behavior, parameters, or output structure, 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?

There is no output schema, so the description correctly explains the full return dict, list truncation envelopes, and how to interpret stormCount. A concrete example is included. The only minor ambiguity is precedence when both sessions and target are provided, but the 'or' phrasing sufficiently signals that they are alternative modes.

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 does. All 8 parameters are documented with defaults, meaning, and interactions: since_hours applies when sessions is omitted, target triggers live collection, and sessions must contain specific fields. This adds substantial 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 states a specific verb and resource: it detects login storms and ranks the slowest login/boot contributors. It answers a concrete question and is clearly distinct from sibling tools like endpoint_list or endpoint_reboot because it is a pure aggregation and analysis operation.

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

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

It gives explicit guidance on input modes: pass 'sessions' for pure analysis, or use a target to pull live data via session_list. It also frames the tool around the question 'is this a morning login storm...'. It does not explicitly list when not to use this tool relative to siblings, but the decision 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?

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 provided, the description carries the full burden of disclosure. It clearly labels the tool as '[READ]' (read-only), states 'no live collection' (no side effects), and reveals the internal check is 'an exact string match on patchLevel — a transparent check, not a version-semantics parser.' It also discloses the important nuance that 'the rate is always computed over the whole fleet, never over the capped list,' which prevents misinterpretation of the limited output.

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

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

The description is structured with a clear opening summary, then separate Args, Returns, and Example sections. It is somewhat verbose but every sentence contributes critical information, such as the fleet-wide rate computation caveat. The front-loading of the purpose and the injection constraint ensures an agent quickly understands the tool's role.

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 computation tool with 4 parameters and no output schema, the description is remarkably complete. It details the return dictionary keys, explains the default target_patch behavior, specifies the compliance rule (exact string match), and clarifies the non-compliance listing truncation. Combined with the clear injection requirement and example, an agent has everything needed to call 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 fully explain each parameter. It does: 'endpoints: Injected inventory rows to evaluate (e.g. from endpoint_list)', 'target_patch: Desired patch level; omit to use the fleet-majority level', 'sla_pct: Compliance SLA threshold percent; default 95.0', and 'limit: Max non-compliant endpoints to return (default 200)'. This fully compensates for the schema gap, even providing a concrete example.

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 clear verb and resource: 'Patch-compliance SLA measure: % of the fleet on the target patch level.' It explicitly distinguishes itself from the sibling patch_status by stating it 'Reframes patch_status (the patch-level distribution) as an SLA/compliance verdict,' making its unique role unambiguous.

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

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

It explains when to use this tool by noting it is 'Injected-only' and expects 'endpoints' from inventory (e.g., endpoint_list), and frames its relationship to patch_status as a reframing into SLA terms. While it does not explicitly list when NOT to use it or name alternatives like drift_report, the injected-data constraint and the SLA focus provide clear 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 behavioral burden. It labels the operation [READ], documents the fallback to fleet-majority when target_patch is omitted, and explains truncation semantics and how to re-run with a higher limit. This is transparent about data source behavior and output limits.

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

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

The description is compact and well-structured into a summary line, Args list, and Returns paragraph. Every sentence carries useful information, and the return-type detail is justified because there is no output 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?

Given no output schema and no annotations, the description covers parameter semantics, return dict shape, truncation behavior, and the remedy for truncated results. It omits explicit comparison to patch_compliance, but for a stateless read tool the invocation and output guidance are essentially 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's Args section fully compensates by explaining all four parameters: target_patch's defaulting behavior, endpoints as injected inventory that skips live collection, target as a config name with default, and limit as the max behind-endpoints with a default of 200. This adds meaning well beyond the raw schema types.

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 '[READ] Patch-level distribution + which endpoints are behind the target level,' which names a concrete resource and read action. It clearly states what the tool computes, though it does not explicitly differentiate itself from the sibling patch_compliance.

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 parameter-level usage tips, such as omitting target_patch to use the fleet-majority level and injecting endpoints to skip live collection, but it gives no guidance about when to prefer this tool over patch_compliance or other siblings. There is no when-to-use, when-not-to-use, or alternative routing.

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?

With no annotations, the description carries full burden. It discloses dispatching the inverse tool, the governed execution, dry-run preview, and one-time token use. Lacks explicit mention of side effects like token consumption or error handling, but covers key behaviors.

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?

Five sentences with clear structure: purpose statement, behavioral details, parameter list. Front-loaded with '[WRITE][risk=medium]'. 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?

Describes parameters and overall mechanism, but lacks output description or error conditions. With no output schema, the agent is left guessing the return value. Adequate for a simple tool but not fully complete.

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

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

Schema coverage is 0%, so description must compensate. It explains each parameter: undo_id source, dry_run purpose, and target pass-through. Adds meaningful context beyond schema types and defaults.

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. It references undo_list as the source of undo IDs, distinguishing it from listing tools and other mutation tools like retry_pipeline or cancel_pipeline.

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

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

Provides context for use: apply undo from undo_list, preview with dry_run, and notes that each token can only be applied once. Does not explicitly list when not to use or alternatives, but the implicit guidance is sufficient.

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 behavioral burden and does so thoroughly. It states this is a read operation, explains the meaning of effectVerified, warns that a false value means the reversed change is only probable, and even cautions against misreporting restore results. It also documents the extra-row fetch behavior that makes 'truncated' reliable.

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

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

The description is front-loaded with the core purpose and flows logically into entry fields, safety caveats, parameters, and return values. Every sentence earns its place, and the Args/Returns structure makes it easy to scan. 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?

There is no output schema, so the description appropriately documents the return dict shape, the meaning of truncated, and how to handle truncation. It covers the caveat about effectVerified, the parameter semantics, and the apply workflow. For a two-optional-parameter list tool, this is comprehensive.

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 fully explain parameters. It does: limit is given a range (1..500) and default (50), and target is explicitly documented as unused but accepted for CLI uniformity. This adds meaningful semantics that the bare schema completely lacks.

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 recorded, not-yet-applied undo tokens (most recent first).' It clearly distinguishes this listing tool from the apply tool (undo_apply) by explaining entries are for later application via undoId. The scope and behavior are 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 when to use the tool: when you need to inspect pending undo tokens before applying them. It explicitly tells the agent to use the returned undoId with undo_apply, connecting the tool to its sibling workflow. It does not fully enumerate exclusions or alternatives, but the workflow context is strong.

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