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

No annotations are provided, so the description must disclose behavior. It indicates a verification operation but does not state that it is read-only, what permissions are required, what happens on a failed verification, or what the response looks like.

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?

It is a single front-loaded sentence with no filler. The density of technical terms makes it harder to parse, but there is no structural waste.

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

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

With no annotations, no output schema, and no parameters, the description should explain prerequisites, success/failure semantics, and at least the basic return contract. It does not, leaving an agent unable to predict the tool's behavior beyond a high-level 'verify' action.

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

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

The tool has zero parameters, so the baseline is 4; the description does not need to explain parameter semantics. It does not add unnecessary parameter detail.

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 ('Verify') and names the evidence and four checks (pinned release hash, signer, OS account, execution model), so the action is identifiable. However, 'fresh running-worker evidence' is domain-specific jargon and the description does not differentiate this tool from siblings such as enclave_status, enclave_audit, or enclave_doctor.

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 statement of when to use this tool, when not to use it, or which sibling it replaces. An agent must infer from the name that this is an attestation/verification step rather than a status or audit call.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses a non-obvious dual behavior — the tool not only reads from the FlightRecorder but also verifies a SHA-256 hash chain — but it never states that the operation is read-only, nor what happens when verification fails (error, flag, truncated result), nor whether verification covers the returned window or the whole log.

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 zero filler: it states the source, the resource, and the verification step in one pass. Nothing could be removed without losing information.

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

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

The tool is simple (one optional param) but has no output schema and no annotations, and the verification behavior raises a real question about what is returned when the hash chain is broken — which the description leaves unanswered. It is adequate for calling the tool but not for interpreting its result.

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

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

Only one parameter exists and schema description coverage is 100%, so the schema already documents limit fully. The description's word "recent" is consistent with that but adds no syntax, bounds, or meaning beyond the schema, so the baseline of 3 applies.

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

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

The description names a specific verb and resource ("Retrieve recent session audit log entries from the FlightRecorder") and adds a second concrete action ("verify its SHA-256 hash chain integrity"), which is enough to distinguish it from siblings like enclave_status or enclave_doctor. It stops short of explicitly contrasting itself with those siblings, so it lands at 4 rather than 5.

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

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

There is no when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. The auditing context is only implied by the words "audit log", leaving the agent to infer the situation that calls for this tool over enclave_status or enclave_doctor.

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

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

With no annotations, the description carries the full burden, and it does disclose one important trait: the tool does not probe a live enclave, implying a purely local, side-effect-free read. It also signals the results are "unverified" qualifications, which usefully warns against treating output as authoritative. It says nothing about permissions, cost, or freshness guarantees, so the disclosure is partial.

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

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

A single sentence with the core action front-loaded and no redundant phrasing. It loses a point because the trailing clause is compressed into opaque terminology rather than plain language an agent can act on quickly.

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

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

For a zero-parameter, non-destructive reporting tool this is close to adequate, and the no-probe constraint is the key safety fact. But with no output schema and no indication of what categories of capability are reported or how they are qualified, an agent cannot predict the response shape or decide whether this call answers its question.

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

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

The tool takes zero parameters and the schema is an empty, closed object, so there is no parameter meaning to convey. Baseline 4 applies; the description correctly implies no inputs are needed by describing a pure local report.

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

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

The verb+object ("Report local capabilities") is clear, but the second half, "explicit unverified qualification boundaries," is dense jargon that does not tell an agent what content actually comes back. It only implicitly contrasts with probing siblings like enclave_status and enclave_doctor rather than naming them, so disambiguation is left to inference.

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 clause "without probing a live enclave" implies the when-to-use condition: call this when you need capability information and must not touch a live enclave. However, no alternative tool is named and no explicit when-not guidance is given, leaving the agent to map that condition onto enclave_status or enclave_doctor itself.

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 supplied, so the description carries the full behavioral burden. It does disclose exactly which artifacts are removed (spool chunks, staging files, multiplexed sockets), which is the single most important fact for a purge operation and hints at low blast radius via 'transient'. It does not state whether deletion is irreversible, whether in-flight transactions on those sockets are aborted, or what permissions 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?

One sentence, front-loaded with the verb and the affected artifacts, with no filler or redundancy. Every clause names a distinct target class.

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

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

With one optional parameter, no output schema, and no annotations, the definition is close to sufficient: the agent knows what is destroyed and where. The remaining gap is operational safety — irreversibility and effect on live sockets/transactions — which matters for a purge tool but is partially mitigated by 'transient'.

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

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

Schema coverage is 100% and the single optional tx_id parameter is documented thoroughly in the schema, including its idempotency semantics. The description adds nothing about tx_id, so the schema does all the work; baseline 3 applies.

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

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

The description uses a specific verb ('Purge') and enumerates concrete resources: transient spool chunks, staging files, and open multiplexed sockets, scoped across Appliance and Bastion. That is far more informative than the bare name. It does not, however, differentiate itself from adjacent siblings such as enclave_heal or enclave_doctor, which likely also remediate state.

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

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

There is no statement of when to invoke this versus enclave_heal, enclave_doctor, or enclave_transaction, and no preconditions or exclusions. The word 'transient' weakly implies it is safe cleanup, but the agent is left to infer the trigger conditions.

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 supplied, so the description carries the full behavioral burden, and it frames the tool purely as 'diagnostics' despite a fix flag that mutates system state. It says nothing about side effects of self-healing, whether checks short-circuit on failure, expected runtime, or required privileges. The layer enumeration is the only real behavioral signal.

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, and the enumeration is packed rather than padded. It loses a point because the dense comma-separated jargon list is harder to parse than a short lead sentence plus scope list.

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 (two optional booleans, no output schema, no nesting), so the description needn't explain return formats. Still, for a diagnostics tool it never indicates what an agent gets back (per-layer pass/fail results) or what 'L1-L7' maps to, leaving the result interpretation unstated.

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

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

Schema description coverage is 100%, and the schema already explains both booleans (fix auto-heals clock skew/UDP policy/Bastion sessions; probe_targets adds SSH checks to TargetNodes). The description only lightly reinforces probe_targets via 'optional TargetNode SSH' and adds no semantics for fix, so it does not exceed 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?

States a specific verb ('Run ... diagnostics') and enumerates exactly what is probed: Host, Appliance clock skew, RDP UDP blackhole guard, VPN tunnel, Bastion VFS RTT, TargetNode SSH. That scope distinguishes it from enclave_status (plain status) and enclave_heal (remediation). The 'L1-L7' label and several component names are domain jargon an agent cannot resolve without prior knowledge.

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

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

Usage is only implied by the word 'diagnostics'; there is no explicit when-to-use, when-not-to-use, or reference to alternatives such as enclave_status or enclave_heal. The overlap with enclave_heal is especially unaddressed given this tool can self-heal via fix=true, so an agent gets no steering on which to pick.

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 supplied, the description carries the full burden, and it does disclose the concrete side effects: MTU is forced to 1350, RDP-over-UDP is disabled, and the Bastion RDP session is reconnected (an inherently disruptive action that drops the live session). What it omits is equally important: whether the operation is idempotent, whether it requires elevated permissions, whether the changes are reversible, and what happens on partial failure across the four steps.

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 dense sentence with the primary action front-loaded and the optional step correctly marked "optionally". The comma-separated chain of four actions is efficient, though it reads as a run-on and could be more scannable as a short list.

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-required-parameter mutation tool with no annotations and no output schema, the description names the effects but leaves out operational context an agent needs: whether the RDP reconnect interrupts the caller, whether re-running is safe, and how to interpret success. The enumerated actions make it usable, but not fully self-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 100%, so both parameters are already documented in the input schema and the baseline is 3. The description does add a little value by mapping "optionally refresh interactive session credentials" onto update_credentials, but it says nothing about tx_id or the transaction-reuse semantics that parameter carries.

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 ("Heal") plus a concrete resource (Appliance MTU) and enumerates the exact actions taken: setting MTU to 1350, disabling RDP-over-UDP, refreshing credentials, and reconnecting the Bastion RDP session. An agent can tell what state changes result. It does not, however, distinguish itself from closely related siblings like enclave_doctor or enclave_clean, which plausibly overlap with "heal".

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

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

There is no explicit statement of when to invoke this versus enclave_doctor, enclave_clean, or enclave_status, and no prerequisites or preconditions (e.g. symptoms that warrant healing, whether the target must be reachable). Usage must be inferred from the word "Heal" alone, which is thin given how many sibling remediation/diagnostic tools exist.

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

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

With no annotations, the description carries the full burden. It adds useful constraints like version-pinning, administrator approval, and no inferred proprietary commands, but omits critical behavior: whether actions are destructive, what apply toggles semantically, approval/transaction requirements, and side effects of disconnect or import_key.

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

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

The description is brief and front-loaded with the core verb, and the second sentence adds a meaningful constraint. However, it is jargon-heavy and under-specified rather than genuinely clear.

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

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

This is a potentially mutating lifecycle tool with four undocumented parameters, no annotations, and no output schema. The description provides high-level framing but lacks essential operational context to invoke it safely and 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% for four parameters. The description loosely hints at plan/apply and administrator approval, but never explains the action enum values, tx_id, approval_digest format, or how apply changes behavior.

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 pair ('Plan/apply') and resource ('provider lifecycle recipe'), but 'recipe' and 'proprietary commands' are opaque jargon. It does not clearly distinguish the tool from siblings like enclave_transaction, enclave_doctor, or enclave_capabilities.

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 implies an administrator-approved prerequisite and suggests planning versus applying, but gives no explicit guidance on when to use this tool versus the many enclave_* and node_* siblings. There is no action-specific routing or exclusion guidance.

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

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

Since no annotations are present, the description must carry the behavioral burden. It is highly transparent by specifying the exact mechanism used ('using `egw stdio-proxy %h %p''), which informs the agent of the underlying implementation and expected functionality.

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 definition is highly efficient. A single sentence covers the function, the mechanism, and the intended application, with no superfluous wording.

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 configuration generation tool with low complexity, the description is complete. The agent knows the purpose, the input required, and the expected operational outcome (a usable SSH snippet) for various real-world scenarios.

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 high (100%), setting the baseline. The description identifies the parameter as a 'Host alias prefix,' which accurately maps to its technical function but does not add unique semantic meaning beyond the structured 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 explicitly states the action ('Generate') and the resource ('OpenSSH ~/.ssh/config snippet'). It is clearly distinguishable from surrounding tool categories like 'enclave_status' or 'node_exec' as it focuses on configuration generation rather than system 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?

The description clearly defines the use case by mentioning 'native ssh/rsync/IDE Remote-SSH,' telling the agent when this tool should be prioritized. It implies usage by relating it to common development workflows and tooling.

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

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

There are no annotations, so the description must carry the behavioral burden. 'Retrieve' implies a read-only operation, but the description does not state permissions, side effects, freshness, rate limits, or return format, leaving a notable but not complete transparency gap for a status tool.

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

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

The description is a single front-loaded sentence that lists the monitored components without filler. Every phrase contributes to scope, so it is appropriately 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 zero-parameter read tool the description covers what is monitored, but with no output schema it does not describe the return structure of the health telemetry. It also does not help the agent choose between this and siblings like enclave_doctor or enclave_audit.

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 zero input parameters, there is no parameter meaning to add, and the baseline for 0 params is 4. The empty schema with additionalProperties false is consistent with the description's no-argument status retrieval.

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 ('Retrieve') and resource ('health telemetry') and names the monitored components, so the core purpose is clear. It does not explicitly contrast with sibling status or diagnostic tools like enclave_doctor or enclave_audit, which keeps it at a 4 rather than 5.

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

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

The description gives no explicit when-to-use or when-not-to-use guidance and does not name alternatives among the many enclave_* and node_* siblings. At most it implies a status-check use case through 'health telemetry'.

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 supplied, the description carries the full behavioral burden, and it only partly delivers. 'Identity comes from the authenticated connection' is genuinely useful auth context, and the cancellation/indeterminate wording signals mutation. However, it says nothing about side effects, idempotency, permissions required, or what the 'reconcile' and 'maintain' actions actually do to state.

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

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

Two sentences, front-loaded with the capabilities and closing with the identity/auth note. There is no filler. The density is high but not padded, so the length is appropriate to the content.

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

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

For a tool with no annotations, no output schema, and a five-value action enum, this description is only partly sufficient. It covers the read and cancel paths but leaves 'reconcile', 'maintain', and pagination undefined, which are exactly the gaps an agent needs filled before invoking a state-mutating transaction 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 needed to compensate for all three parameters and largely fails. It gestures at the action modes but never explains 'tx_id' versus list behavior, and 'limit' (default 25, implying pagination) is not mentioned at all. The two unexplained enum values, 'reconcile' and 'maintain', leave the most consequential parameter ambiguous.

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

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

The description names concrete verbs and resources: getting/listing operation state and retained result, requesting cancellation, and marking an expired execution indeterminate. That is far more specific than the bare name 'enclave_transaction'. It loses a point because the 'maintain' action in the enum is never explained, and nothing distinguishes this tool from the sibling 'enclave_status'.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no sibling is named as an alternative. An agent reading this must infer that 'get/list' is the read path and 'cancel'/'reconcile' are the write paths purely from the wording. The relationship to enclave_status or enclave_audit is left entirely unstated.

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 supplied, so the description carries the full disclosure burden. 'Background' implies long-lived state, but the description never says whether tunnels survive the session, what permissions or transport state are required, whether starting a port that is already bound errors, or what 'stop' does to in-flight connections. For a stateful networking primitive this is a substantial gap.

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; the action verbs and the resource types are each stated once and carry all the needed weight.

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

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

With no output schema and no annotations, the description should say what 'list' returns (tunnel IDs, ports, targets) and how a started tunnel is referenced later for 'stop'. It covers the operations but leaves the observable behavior of the tool undocumented.

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

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

Schema description coverage is 100%, with both enums and conditional requirements (target_host/target_port required only when action='start' and mode='tcp') fully documented in the schema itself. The description adds essentially nothing beyond that, so the baseline 3 applies.

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

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

The description names specific verbs (start, stop, list) and specific resources (TCP port forwards, SOCKS5/HTTP proxies) plus the transport used (RdpVfsTransport). It is immediately clear what the tool does. It stops short of differentiating from siblings such as node_http_request or node_transfer, which an agent might plausibly confuse with a proxy/forwarding tool.

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

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

There is no explicit when-to-use or when-not-to-use guidance, no prerequisites (e.g. an active RDP/VFS session), and no warning about cleanup or persistence of background tunnels. The word 'Dynamically' hints at runtime lifecycle but does not tell the agent under what circumstances to pick this over a direct request tool.

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 supplied, so the description carries the full behavioral burden, and it delivers only one trait: password is not exposed on the CLI. It says nothing about whether arbitrary DML/DDL is permitted, what confirm_destructive actually guards, whether queries can block or time out, or what a caller gets back. For a tool that can run any SQL against a production node, this is a large disclosure gap.

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

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

A single sentence that front-loads the action and parenthesizes the mode distinction, with no filler. It is efficient, though its brevity is partly the cause of the transparency and parameter gaps.

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

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

Assessed relative to tool complexity: an 8-parameter mutation tool with zero annotations and no output schema needs more than one sentence. The description omits confirmation semantics, credential sourcing, and any indication of result shape, leaving an agent to guess before issuing potentially destructive SQL.

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 only 50%: db_user (default root), database, db_password_env, and confirm_destructive have no schema descriptions at all. The description does not compensate — it never explains that the password comes from an environment variable, what database defaults to, or when the destructive-confirmation flag must be set. The container mode is the only parameter behavior the description clarifies.

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 concrete verb and resource ('Execute a SQL statement on a TargetNode') and adds the two execution modes (directly on host or inside a Docker container). It does not distinguish this tool from siblings like node_exec or enclave_transaction, so an agent cannot tell from the text alone why it should pick this one over shell 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?

There is no when-to-use guidance, no mention of prerequisites (credentials, reachable node, engine-specific quirks), and no comparison to the many sibling tools that could also reach a database indirectly. The only implied routing is 'use this instead of a CLI client', which is a hint rather than guidance.

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

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

With no annotations, the description carries the full behavioral burden and it does add real context: Base64 transport and secret scrubbing of output. It omits other traits an agent needs for arbitrary code execution — the destructive-command gate, sudo password requirements, timeout kill behavior, and output format — so the disclosure is partial rather than complete.

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 zero filler; the verb leads and the constraints follow. Nothing can be trimmed without losing information.

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

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

This is an eight-parameter arbitrary code execution tool with no annotations and no output schema, so the description must explain return values, failure/timeout semantics, and the destructive-confirmation gate — it explains none of these. For a tool of this risk level the single sentence is materially under-specified.

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

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

Schema description coverage is 100%, so the baseline is 3 and the eight parameters are already documented individually. The description's mention of Base64 transport and secret scrubbing weakly reinforces the 'script' and 'secret_env' parameters but adds no syntax, format, or precedence detail 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 names a specific verb and resource ('Execute a shell/PowerShell script') and constrains the targets to '@appliance', '@bastion', or a configured TargetNode, which separates it from file-oriented siblings like node_read_file and node_patch_file. It does not explicitly name a sibling it is not, so sibling differentiation is left partly to inference.

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 says where the script runs but never says when to choose node_exec over node_patch_file, node_transfer, or node_db_query, nor when it is inappropriate. The only guidance in the whole definition sits in the schema ('confirm_destructive'), not in the description.

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

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

No annotations are provided, so the description carries the full behavioral burden and largely drops it. For an arbitrary outbound network primitive it says nothing about what is returned (status, body, headers), timeout or failure behavior, redirect handling, credential/header propagation, or the security implications of insecure_tls — all of which matter for safe invocation.

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

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

A single front-loaded sentence with the action and scope stated immediately and no filler. Its brevity is appropriate in form, though it reflects under-specification rather than disciplined economy.

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 6-parameter tool with a nested headers object, no annotations, and no output schema, the description is too thin. An agent cannot tell what the call returns, whether failures surface as errors, or how insecure_tls should be used, leaving key invocation decisions unaddressed.

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

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

With only 33% schema description coverage across 6 parameters, the description needs to compensate but largely does not. 'From inside a TargetNode' does clarify that node identifies the host executing the request, but method, body, headers, and insecure_tls receive no explanation beyond their bare names 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 states a specific verb and resource ('Perform an HTTP/HTTPS request') and adds meaningful scope: the request originates 'from inside a TargetNode' and is aimed at inspecting internal services. This distinguishes it conceptually from siblings like node_exec or node_read_file, though those alternatives are not named explicitly.

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

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

There is no when-to-use vs when-not guidance and no mention of alternatives such as node_exec, which could also be used to reach an internal service. The phrase 'to inspect internal services' hints at intent but gives no conditions, prerequisites, or exclusions an agent could act on.

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 at all, the description carries the full behavioral burden. It does valuable work by disclosing atomicity, the UTF-8 constraint, and the optional SHA-256 precondition that guards against concurrent overwrite. However, it omits critical failure semantics for a mutation: what happens if 'target' is not found, whether multiple matches are an error, and whether partial writes are possible on failure.

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

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

A single front-loaded sentence with no filler; the atomicity and precondition qualifiers are the most decision-relevant facts and appear early. Slight redundancy in re-listing the three node target strings, which the schema already enumerates.

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 seven-parameter mutating tool with no annotations and no output schema, the description covers the safety-relevant headline (atomic, precondition-checked) but leaves the agent guessing about match failure, permission requirements, and result reporting. It is adequate but short of what this operation's risk profile warrants.

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

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

Schema description coverage is 100%, so all seven parameters, including tx_id idempotency and as_root sudo behavior, are already documented in the schema. The description only echoes the node-target values and the SHA-256 precondition, adding essentially no meaning beyond the structured fields. Baseline 3 applies.

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

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

States a specific verb and resource ('Atomically replace a target block inside a remote UTF-8 file') and names the valid targets ('@appliance', '@bastion', or a TargetNode). It is clearly distinguishable from read-oriented siblings like node_read_file, though it never explicitly contrasts itself with node_exec or node_transfer, which could also mutate a remote file.

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 when-to-use or when-not-to-use guidance. The description never says to prefer this over node_transfer or node_exec (e.g. sed), nor does it state prerequisites such as the file already existing or the caller needing write access. The only usage signal is the implied 'replace a block atomically', which the agent must infer.

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 supplied, the description must carry the full behavioral burden, and it does disclose two non-obvious traits: results are hashed with SHA-256 and secrets are scrubbed, meaning output may be redacted from the on-disk content. It still omits permissions expectations, behavior on non-UTF-8 or missing files, and whether scrubbing can silently alter what the agent reads.

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 the verb front-loaded and no filler; the parenthetical line-range clause and the trailing hash/scrubbing clause both carry information. It is dense to the point of being telegraphic, but nothing is wasted.

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 6-parameter read tool with full schema coverage and no output schema, the description covers the essentials: encoding limit, range support, node scope, and the hash/scrub side effects. Remaining gaps are error behavior and elevation semantics for as_root, which the schema only partly addresses.

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

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

Schema coverage is 100%, so every parameter is already documented, and the baseline of 3 applies. The description adds only marginal meaning beyond the schema: that the target set is '@appliance', '@bastion', or a TargetNode, and that line-range reads are supported, both of which are already in the property descriptions.

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

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

The description uses a specific verb ('Read') plus resource ('file'), and adds scoping detail the name alone does not carry: UTF-8 text only, optional line range, and the three node targets. That distinguishes it in practice from write-oriented siblings such as node_patch_file and node_transfer, though it never names a sibling 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?

Usage is only implied: 'Read a UTF-8 file' suggests inspection rather than mutation, so an agent can infer it is the wrong tool for editing or copying. There is no explicit when-to-use statement, no guidance on choosing between node_read_file and node_exec (e.g. cat), and no stated exclusions such as binary files.

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 supplied, the description carries the full burden, and it does meaningfully well: it discloses that 'scoped grants' are required, that each file commits atomically, and that extra destination files are retained (i.e., this is not a mirror/delete sync). That retention note is a genuinely important behavioral trait an agent could not infer from the schema; the gaps are failure/rollback behavior and overwrite semantics for conflicting files.

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 well-formed sentence with the primary action front-loaded and the behavioral caveats in a subordinate clause. Dense but every clause carries information; no filler 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?

For a 7-parameter mutating tool with no annotations and no output schema, the description covers the highest-risk unknowns: privilege scoping, atomicity, and the fact that destination extras survive. It stops short of describing what the result looks like or what happens on partial failure, but the critical decision inputs are present.

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

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

Schema description coverage is 100%, so the schema already documents all seven parameters including node identifiers, direction enum, exclude globs, tx_id reuse semantics, and as_root. The description adds essentially no parameter-level meaning beyond what is already structured, so the baseline of 3 applies.

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

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

The description gives a specific verb and resource: 'Synchronize a directory between the Host and a node', with the direction implied by the Host/node framing. It does not explicitly differentiate itself from the sibling node_transfer or node_read_file, so an agent must infer that this is the bulk-directory 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?

The word 'directory' implies this is for whole-directory synchronization rather than single-file operations, which weakly routes an agent away from node_transfer/node_read_file. However, there is no explicit when-to-use, when-not-to-use, or named alternative, and no guidance on push vs pull selection beyond what the schema enum already says.

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 supplied, so the description carries the full behavioral burden. It does add real value by disclosing SHA-256 verification and block delta sync, but those are already partially echoed by the use_delta schema field, and it says nothing about overwrite behavior, atomicity, what happens on hash mismatch, or failure/return semantics for a write operation.

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

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

A single front-loaded sentence with no filler: verb first, then endpoints, then verification guarantees. The embedded list of node identifiers is slightly dense but 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?

For a seven-parameter mutation tool with no annotations and no output schema, the description covers intent and verification but leaves behavioral gaps an agent would want, notably overwrite/merge behavior on the destination and what the caller receives on success or hash failure. Rich schema coverage compensates for the parameter side, but the mutation semantics remain 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 100%, so all seven parameters, including the direction enum and the tx_id idempotency note, are already documented in the schema. The description adds no syntax, format, or constraint detail beyond what the schema provides, making baseline 3 appropriate.

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

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

The description names a specific verb pair (push/pull) and resource (a file) plus the exact endpoint universe ('@appliance', '@bastion', TargetNode), so an agent knows this is a file-transfer tool rather than a read/patch/exec tool. It stops short of explicitly differentiating itself from siblings like node_sync or node_read_file, but the verb+resource is unambiguous.

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

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

There is no when-to-use guidance: nothing says when to choose node_transfer over node_sync, node_read_file, or node_patch_file, and no prerequisites or exclusions are stated. The agent must infer usage purely from the verb and the node list.

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