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

The annotations already indicate destructiveHint=true, so the description adding 'stops all future occurrences' provides useful context about the scope of the destructive action. However, the description does not disclose additional behavioral details such as irreversibility, whether past occurrences are affected, or any required permissions beyond the annotation hints.

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

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

The description is a single concise sentence that front-loads the action and consequence. It is efficient with no wordiness, earning a high mark for conciseness, though it is slightly under-specified for full structural completeness.

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 one parameter, an output schema, and clear annotations for its destructive nature, so the description is mostly sufficient for an agent to invoke it correctly. The main gap is the lack of guidance on where to find schedule_id or how the cancellation result is returned, but the output schema could cover the latter.

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

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

The schema describes schedule_id with minimal detail (type and title only), and the description does not elaborate on what schedule_id refers to or how to obtain it. With only one parameter at 0% schema description coverage, the description does not compensate for the lack of parameter semantics; however, the single parameter is fairly self-explanatory in context.

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 ('Cancel a recurring schedule') and its effect ('stops all future occurrences'). It clearly distinguishes this from scheduling or listing tools among siblings, though it does not explicitly name an alternative tool for other 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 description implies when to use the tool: when the user's intent is to stop a recurring schedule. It does not provide explicit guidance on when not to use it or mention any alternative tools (e.g., schedule_plan for creating schedules). This is adequate but leaves the agent to infer the 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?

Annotations already indicate destructiveHint=true, so the cancellation as a destructive operation is covered. The description adds the useful behavioral detail that cancellation only applies before execution. It does not discuss irreversibility or side effects, but given the annotation coverage 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 a single concise sentence with no filler. The core purpose and timing constraint are front-loaded, making it easy for an agent to quickly 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?

For a simple one-parameter cancel action, the description covers the essential behavioral scope. The output schema and annotations provide additional safety information. It could be slightly more complete by pointing to how to find plan_id or distinguishing from canceling recurring schedules, but it is largely sufficient.

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 by explaining the plan_id parameter, such as where to obtain it or that it must reference a pending scheduled plan. While plan_id is a self-evident string identifier, the description adds no parameter-level meaning beyond the schema.

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

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

The description clearly states the specific action (cancel), the resource (a pending scheduled plan), and the timing constraint (before it executes). This makes the tool's purpose distinct from siblings like cancel_recurring_schedule and reschedule_plan.

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 usage context: only pending scheduled plans that have not yet executed can be canceled. It does not explicitly mention alternatives or when-not-to-use cases, but the pending/before-executes condition gives adequate guidance for the common scenario.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the mutation risk is known. The description adds little behavioral context: it doesn't say whether the commit is irreversible, what side effects occur, or whether it can result in execution or scheduling, even though the tool name contains 'or_schedule'. No contradiction with annotations, but no added transparency either.

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 sentence and visually concise, with no repetition. However, it spends words on an opaque phrase ('runtime-owned physical execution and scheduling boundary') instead of explaining the tool's behavior, making it under-specified rather than effectively 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?

For a destructive tool with 3 required parameters, no output schema, and many closely related sibling tools, one vague sentence is far from complete. It omits parameter semantics, expected outcomes, and the relationship to execution and scheduling tools, so an agent lacks critical 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?

The schema provides no parameter descriptions, and the description does not compensate: the bundle_digest is loosely echoed by 'bundle', but scenario_id and members are completely unexplained. The members field is an array of arbitrary objects, which particularly needs semantic guidance. An agent cannot know what values are valid or what these parameters mean.

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

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

The description specifies a concrete action ('Commit') and a resource ('one validated bundle'), so the core purpose is identifiable. However, it does not state what committing actually does or how this differs from the sibling execute_plan or schedule_plan tools; the phrase. 'runtime-owned physical execution and scheduling boundary' is abstract jargon.

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 word 'validated' implies the bundle must already be validated before this tool is used, which gives some usage context. But it provides no explicit when-to-use/when-not-to-use guidance and no alternatives among the many workflow siblings, so an agent cannot reliably choose between this, execute_plan, schedule_plan, or request_approval.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the 'refresh' capability and the canonical inventory context, but it does not explain what refresh does cotidiano (e.g., whether it triggers re-discovery, side effects, or rate 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 a single front-loaded sentence with no wasted words. It is concise and readable, though it is also too sparse to fully serve as guidance.

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 three optional parameters and an output schema, the description covers only the core action. It omits parameter semantics and usage context, leaving the agent to infer what types, area_id, and refresh actually control.

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 offers no meaning for the three parameters (types, area_id, refresh). 'refresh' is only implied by the verb, and types/area_id are completely 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?

The description uses a specific verb pair 'Read or refresh' and a precise object, 'the canonical semantic device inventory.' This clearly distinguishes the tool from siblings like get_state or validate_command, which target different resources.

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 use this tool versus alternatives, nor any mention of exclusions or conditions. The description does not explain when 'refresh' should be used or when a simple read 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?

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the description is not required to restate destructiveness. It adds useful context about pre-validation and runtime safety checks, but does not explain consequences, irreversibility, or approval requirements beyond what the parameter approval_id hints at.

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 wasted words. It conveys the core purpose and an important prerequisite, though brevity leaves some behavioral details to inference.

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 tool with five parameters and no schema description coverage, this is incomplete. It omits the meaning of dry_run, approval_id, and bundle_digest, and does not describe what 'runtime safety checks' entails or what the agent should expect after execution. The output schema exists, so return-value documentation is less critical, but invocation guidance is still thin.

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 compensate for the five parameters. It only vaguely maps to validation_digest via 'previously validated' and gives no meaning for dry_run, approval_id, bundle_digest, or plan_id. This 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 uses a specific verb and object ('Execute ... plan') and adds the qualifier 'previously validated' to distinguish this from plan creation or scheduling. It does not explicitly differentiate from schedule_plan or commit_or_schedule_bundle, but the execute/validate/schedule contrast is clear from the sibling names.

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 'previously validated plan' implies that validate_plan should happen first, and 'after runtime safety checks' suggests a required sequence. However, it does not explicitly say when to use this instead of schedule_plan, or mention any exclusions or 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?

The annotations already declare readOnlyHint=true and destructiveHint=false; the description reinforces this with 'without changing runtime state'. It adds the qualifier 'typed optimization result' but does not disclose behavior like whether it returns a summary, how it handles invalid inputs, or whether it requires an existing optimization context. Given annotation coverage, this is adequate 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?

One concise sentence that leads with the action and resource, then adds the key side-effect guarantee. Every word earns its place with no unnecessary elaboration.

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

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

For a simple read-only explanation tool with one object parameter, annotations already covering safety, and an output schema available, the description covers the essentials. It could be more complete by referencing the relationship to optimize_scenario or describing the expected result object, but the current level is sufficient for basic 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 single 'result' parameter has no schema description, and schema description coverage is 0%. The description's phrase 'typed optimization result' gives only a high-level hint and does not explain the expected shape, fields, or constraints of the object. With zero parameter descriptions in either schema or description, the agent is left without meaningful parameter guidance.

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 ('Explain') and a specific resource ('typed optimization result'), and explicitly notes it makes no runtime state change. This clearly distinguishes it from the many mutating siblings like execute_plan, schedule_plan, or optimize_scenario. Even without naming a sibling, an agent can infer its role.

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 whenan agent has a typed optimization result to inspect, and explicitly states it does not change runtime state, which excludes it from planning/execution workflows. It does not name alternative tools or provide explicit when-not conditions, but the context is still reasonably clear.

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

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

Annotations declare readOnlyHint=true and destructiveHint=false, which establishes the safety profile. The description is consistent with this and adds that the result is a 'complete canonical' context for one horizon, but it gives no further behavioral details such as response contents or potential errors. Given the annotations cover the main behavior, this is adequate 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 is front-loaded with the verb and resource. Every word contributes, with no fluff or repetition 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?

Despite having an output schema and read-only annotations, the parameter contract is too vague. An agent cannot reliably construct the 'horizon' object from the description alone, and there is no guidance about the content or format of that nested object. The tool is simple, but the missing horizon semantics leave an important 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?

Schema description coverage is 0% and the sole parameter 'horizon' is an open object with no structure. The description only says the operation is 'for one requested horizon,' which adds minimal meaning but does not explain what fields or format the horizon object should contain. It 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 uses a specific verb ('Read') and identifies the resource ('complete canonical energy context') and scope ('one requested horizon'). It clearly distinguishes an energy-context read operation from sibling tools like get_state by naming the domain and completeness.

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 siblings such as get_state, validate_plan, or explain_solution. The description implies a read use case but does not state when not to use it or name alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's 'Read' adds no new safety information. It contributes only the 'bounded' qualifier, hinting at limits without explaining staleness, rate limits, or output behavior. It is consistent with annotations, so no contradiction.

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 concise sentence that front-loads the core action and target. No wasted words, but it sacrifices valuable information that could be included without structural 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?

With three parameters and zero schema coverage, the description is under-specified. It does not address the optional parameters, the meaning of 'bounded', or when to choose this tool over its many siblings. The output schema helps for return values, but the description alone leaves important gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the three parameters. It mentions 'selected devices', giving some meaning to the required 'devices' parameter, but it does not explain 'allow_stale' or 'capabilities', leaving those semantics entirely unspecified.

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' with a resource 'bounded semantic state snapshots' and a scope 'selected devices'. It clearly identifies the operation and object, and the phrase distinguishes it from siblings like get_energy_context or discover_devices, though not 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?

No guidance on when to use this tool versus alternatives such as get_energy_context or validate_command. The description does not specify prerequisites, use cases, or exclusions, leaving the agent to infer from the tool name alone.

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

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

The description goes beyond the readOnlyHint/destructiveHint annotations by stating the report is 'shared' and 'non-authoritative,' which tells the agent this is not the source of truth and may represent pending/future bindings. With annotations already covering the read-only safety profile, the description adds meaningful behavioral context without contradicting them. It does not mention caching behavior affected by 'refresh,' but that is partially discoverable via the schema.

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

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

A single, front-loaded sentence with no filler. Every phrase earns its place: the verb, the object, the shared/non-authoritative qualifier, and the domain scope.

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 read-only inspector with no required parameters and an output schema present, the description is nearly complete. The main gaps are not explaining the 'refresh' parameter's behavior and not stating explicitly that asset_types filters the report; still, the readOnlyHint, destructiveHint, and output schema carry much of the contextual burden.

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 does not compensate for the schema's lack of parameter meanings. However, there are only two optional parameters: 'refresh' is self-explanatory as a boolean defaulting to false, and 'asset_types' is reasonably inferable as a filter for which asset types to include. The description mentions 'battery and EV bindings,' which maps loosely to asset_types, but does not explicitly explain either parameter.

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

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

The description states a specific verb ('Read') and resource ('shared, non-authoritative commissioning report') and adds the qualification 'for future battery and EV bindings.' That scope is enough to distinguish it from sibling tools like get_state or list_audit_events, and the qualifier 'non-authoritative' adds important nuance about the data's trust level.

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 a read-only reporting tool and uses language like 'shared... report' and 'non-authoritative,' which helps an agent infer it is for inspection rather than execution. However, it does not explicitly state when to use it over alternatives or when not to use it, leaving the agent to infer from the readOnlyHint annotation and sibling names.

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

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

Annotations already establish readOnlyHint and non-destructive behavior. The description adds useful context with 'bounded' and 'filterable,' but it does not specify how events are bounded, what the default time window is, or what event types can be filtered. It adds some value beyond annotations but remains vague.

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, front-loaded sentence with no filler. The key ideas—bounded, filterable, runtime decisions—are all present without unnecessary elaboration.

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 that all parameters are optional and an output schema exists, a short description is acceptable. However, with zero schema descriptions, the tool description could have named the available filters or mentioned the default limit to support correct invocation. It is adequate but leaves meaningful gaps.

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

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

Schema description coverage is 0%, and the description does not explain any of the four parameters: limit, since, event_type, and subject_id. The word 'filterable' hints at filtering, but it does not map to the actual parameter names or expected formats, leaving the agent to infer semantics entirely from 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 ('Query') and resource ('bounded, filterable audit trail of runtime decisions'), making the tool's purpose unmistakable. It also naturally distinguishes this tool from the sibling planning/execution tools, none of which are audit-related.

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 should be used when an agent needs to inspect runtime decision audit records, and no sibling tool competes for that role. However, it does not explicitly say when to use this tool versus alternatives or 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context that results include the next occurrence, but it does not disclose whether the list is paginated, ordered, or limited in any way.

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, compact sentence that front-loads the action and resource. Every word earns its place; there is no fluff 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 zero-parameter, read-only list tool with a valid output schema, the description is largely complete. The only gap is the absence of details on filtering, ordering, or pagination, which are unlikely to be critical given the tool's simplicity.

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

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

The tool has 0 parameters and schema coverage is 100%, so there is nothing to document. The description's mention of 'active' schedules clarifies the scope of the result set, which is useful semantic context beyond the empty schema.

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

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

The description states a clear verb ('List') and resource ('active recurring schedules'), and mentions 'next occurrence', which gives the agent a precise idea of what is returned. It is distinguishable from siblings like cancel_recurring_schedule and schedule_recurring_plan, though it does not explicitly differentiate itself.

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

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

The description implies a read-only listing operation, which fits naturally alongside other list/get tools, but it does not state when to prefer this tool over siblings like list_scheduled_plans. There is no explicit when/when-not guidance or naming of alternatives.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows this is a safe read operation. The description adds little behavioral context beyond that, but it is consistent with the annotations and the simple nature of the 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, focused sentence that states the resource and the filtering condition with no wasted words. It is appropriately concise for a zero-parameter list operation.

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

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

For a simple list tool with no parameters, an output schema present, and read-only annotations, the description is complete enough. It tells the agent what will be returned — plans awaiting execution — without needing to explain return values or parameter 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 tool has zero parameters, so the description has no parameter semantics to explain. The baseline for zero-parameter tools is 4, and nothing in the description detracts from that.

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 has a specific verb ('List') and resource ('plans') and adds a clear status qualifier ('currently pending their scheduled execution time'). This clearly distinguishes it from sibling tools like list_recurring_schedules, which target recurring schedules rather than one-time pending plans.

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

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

The description implies when to use it — when you need plans that have not yet reached their scheduled execution time. However, it does not explicitly mention alternatives or state when not to use it, such as distinguishing from list_recurring_schedules or listing already executed plans.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces this by stating no physical commands are executed. It also adds a useful behavioral trait, determinism, which is not present in the annotations. This is good added context beyond structured metadata.

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, tightly written sentence that front-loads the core purpose and immediately adds a critical scoping constraint. Every word earns its place and there is no padding.

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?

Although an output schema exists and annotations cover the safety profile, the tool still requires a nested scenario object with zero documented properties. The description gives no practical invocation guidance, and the relationship to validate_scenario and execute_plan is only implied. This is not enough for reliable, correct use.

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

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

Schema description coverage is 0%, and neither the scenario object nor validate_proposal is explained in the description. The agent is left without any guidance on what shape the scenario object should take or what validate_proposal controls. The description does nothing to compensate for the undocumented 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 uses a specific verb ('compute') and a clear resource ('deterministic proposal'), and explicitly distinguishes the operation from physical execution. This makes it easy to tell apart from siblings like execute_plan, schedule_plan, and validate_scenario.

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 'without executing physical commands' clearly implies a planning or proposal-only usage, which helps separate it from execute-style siblings. However, it does not explicitly state when to use this tool over validate_scenario or explain_solution, leaving some selection judgment 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?

Annotations already indicate side effects (readOnlyHint=false, destructiveHint=true). The description adds valuable behavior: the grant is server-authoritative, the returned approval_id is single-use and bound to the plan's current validation digest, and operator identity can only be injected by a trusted host. No contradiction with annotations.

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

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

The description is three sentences with no filler. It front-loads the core purpose, then appends auth/compatibility context and return-value behavior, all of which earn their 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?

This is a side-effectful approval tool in a broad sibling set, so an agent would benefit from more explicit routing versus validate_plan or execute_plan, and from more detail on the optional digest parameters. The output-schema presence reduces the need to explain return shape, and the single-use approval_id behavior is already covered.

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 carries a heavier burden. It explains operator_token's special purpose and clarifies validation_digest's binding relationship, but plan_id, bundle_digest, and recurrence_digest are left mostly to inference from their names. Partial compensation, not complete.

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: issuing a server-authoritative approval grant for a plan requiring confirmation. This clearly distinguishes it from sibling tools like validate_plan or execute_plan, since the focus is on approval rather than validation or execution.

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 identifies when the tool applies ('for a plan requiring confirmation') and gives concrete usage guidance around operator_token, noting it is only for local/dev compatibility and that callers should never supply the recorded operator identity. It does not explicitly name alternatives, but the intended 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?

Annotations already indicate readOnlyHint=false and destructiveHint=true, so the mutating nature is known. The description adds meaningful behavioral context beyond this: the operation is fail-closed, and changes require re-validation and re-approval before admission. This helps an agent understand that the tool may not immediately commit the change and that additional workflow steps are required.

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 front-loaded, with the core purpose in the first sentence and an important behavioral caveat in the second. It is not overly verbose, though terms like 'legacy generic mutation,' 'fail-closed,' and 'admission' are somewhat jargon-heavy 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?

Given four parameters, zero schema description coverage, and a destructiveHint annotation, the description is not complete enough for reliable invocation. It explains the purpose and approval workflow but leaves optional parameters such as schedule_revision and validation_digest undocumented, which may be required in certain approval contexts. The presence of an output schema helps, but the input-side gap remains material.

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 four parameters. The only hint is 'changed time,' which loosely maps to execute_at, but plan_id, schedule_revision, and validation_digest are left completely unexplained. This is a significant gap for an agent trying to construct a valid 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 tool's core action: 'Request a temporal revision for a pending plan.' It identifies a specific resource ('pending plan') and a distinct operation ('temporal revision'), which helps separate it from scheduling, cancellation, and execution siblings. However, it does not explicitly name a sibling alternative, so it falls just short of the strongest 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 implies when to use this tool: when a pending plan needs a time change. It also provides important workflow context by noting the legacy generic mutation is fail-closed and that a changed time must be validated and approved again, guiding the agent toward validation/approval follow-up steps. Explicit 'do not use when...' exclusions are absent, but the context is reasonably 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 adds meaningful behavior beyond the destructiveHint annotation by stating that 'the plan still goes through every existing safety check when its time arrives'. This reassures the agent that deferring execution does not bypass safety, and it aligns with the annotation rather than contradicting it.

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, and the most important operational fact (scheduling a previously approved plan for future execution) is front-loaded. Every clause 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 description gives a solid high-level picture and notes the safety-check behavior, but it does not explain how to obtain or populate the required validation_digest, what approval_id/bundle_digest are for, or how this interacts with sibling tools like cancel_scheduled_plan. The presence of an output schema and annotations helps, but the parameter gap limits completeness for a 5-parameter 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 description coverage is 0%, so the description carries the burden of explaining parameters, but it only implicitly maps 'future time' to execute_at and 'validated/approved' to validation_digest/approval_id. It provides no explicit meaning for plan_id, validation_digest, approval_id, or bundle_digest, leaving required parameters 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?

The description uses a specific verb ('Schedule'), names the resource ('a previously validated/approved plan'), and states the key distinction ('at a future time, instead of immediately'). This clearly distinguishes it from immediate execution via execute_plan and other sibling scheduling 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 explicitly conditions usage on the plan being 'previously validated/approved' and contrasts with 'instead of immediately', giving the agent a clear contextual trigger. It does not explicitly name alternative tools or exclusions, but the use case is well implied.

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

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

Beyond the annotations, the description discloses that creating a standing automation is an authority act, that approval may be required at creation time, that each occurrence is revalidated, and that confirmation-requiring occurrences are skipped and audited rather than auto-approved. This is exactly the behavioral nuance an agent needs for a destructiveHint=true 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 dense but every sentence earns its place: purpose, approval/authority, runtime safety behavior, and expiry. It is front-loaded with the core action and does not waste words on schema-restatable details.

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

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

For a complex, destructive, 6-param tool, the description covers the essential context: creation-time authority, approval requirements, recurring run-time validation, skip/audit behavior, and optional expiry. An output schema exists, so return-value documentation is not the description's burden.

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 carry parameter meaning. It does: plan_id maps to 'a plan's commands,' time_of_day/timezone to 'fixed local time,' days_of_week to optional weekday restrictions, approval_id to the request_approval flow, and expires_at to how long the automation stays active. Exact formats like time_of_day syntax are not specified, but the functional semantics are all conveyed.

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: 'Schedule a plan's commands to run repeatedly at a fixed local time, optionally restricted to specific weekdays.' This clearly distinguishes recurring scheduling from one-off execution and from the sibling tool schedule_plan.

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

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

The description gives clear context: it is for standing automations, not one-time runs, and it explains when approval_id is required. It does not explicitly name an alternative tool for one-time execution, but the distinction from running commands once is clear 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the useful behavioral detail that no adapter is invoked, which clarifies that validation is non-executing. It does not disclose what happens on failure or whether validation has side effects beyond the annotation guarantees.

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. The core purpose and the critical non-execution qualifier are both front-loaded and clearly expressed.

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 nested object parameters, no schema-level parameter descriptions, and several sibling validation/execution tools. The description gives only the core idea and leaves the agent without enough context to construct a valid command or choose confidently among siblings.

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 does not explain the command object's structure, the meaning of 'semantic command', or the optional agent_request_id. With 0% schema description coverage, the description needed to compensate but provides almost no parameter-level guidance.

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 ('validate'), a resource ('one semantic command'), and a key behavioral qualifier ('without invoking an adapter'). It clearly separates validation from execution, though it does not explicitly distinguish itself from sibling validation tools like validate_plan or validate_scenario.

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 'without invoking an adapter' implies this is a dry-run validation rather than an execution, which gives the agent a sense of when to use it. However, it does not explicitly state when to prefer this over validate_plan, validate_scenario, or execute_plan, leaving the routing partially 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?

The readOnlyHint and destructiveHint annotations already convey that this is a safe, non-destructive operation. The description adds minimal behavioral context beyond validation semantics and the return of policy decisions/digest, but does not explain any validation side effects or constraints. With annotations present, this is adequate 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?

The description is a single, front-loaded sentence with no wasted words. It covers the main purpose and return value efficiently, though it omits additional guidance that could improve usability.

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 an output schema present, return values do not need elaboration, and annotations cover safety. However, the description leaves the 'mode' parameter unexplained and gives no guidance about what constitutes a semantic plan or how this relates to sibling validation/execution tools. For a tool with 0% schema description coverage and a complex nested plan object, this is incomplete.

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 carries the burden of explaining parameters. It indicates the 'plan' is a semantic plan but does not describe the 'mode' parameter or any expected plan structure. This is insufficient for an agent to correctly populate the arguments.

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 ('Validate') and resource ('a semantic plan') and states the expected output ('policy decisions and digest'). It clearly identifies what the tool does, though it does not explicitly distinguish it from sibling validate tools like validate_command or validate_scenario.

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 use this tool versus alternatives such as validate_command, validate_scenario, execute_plan, or schedule_plan. The context implies it is for validating plans before execution, but no explicit when/when-not guidance or alternatives 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's read-only nature is consistent. The description adds that validation checks against canonical devices and capabilities, which clarifies the operation's basis, but does not describe failure behavior, response semantics, or side effects beyond annotations.

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

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

A single sentence with no filler. The key action and subject are front-loaded, and every word contributes meaning.

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

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

The core validation behavior is stated, and an output schema plus read-only annotations are present, reducing the burden on the description. However, the description lacks guidance on how this validation relates to sibling tools and what the scenario object must contain, so it is adequate 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?

The sole parameter, 'scenario', is an open object with additionalProperties=true and no description in the schema. The description adds that it is an 'optimization scenario' and that validation targets 'canonical devices and capabilities', but it does not explain required fields or expected structure, leaving 0% schema coverage undercompensated.

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 ('Validate') and resource ('optimization scenario') and adds the validation basis ('against canonical devices and capabilities'). It distinguishes the tool from siblings like validate_command and validate_plan by the resource type, but does not explicitly contrast 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?

No guidance is given on when to use this tool versus validate_plan, validate_command, optimize_scenario, or explain_solution. There are no prerequisites, exclusions, or alternative routing hints.

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