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

With no annotations, the description carries the behavioral burden. It clearly signals a read operation, but it does not disclose behavior for missing keys, invalid dotted paths, or whether the read is purely local and side-effect-free beyond the word 'Read.'

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 resource, and it earns its place with a useful example. There is no wasted 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?

The tool is very simple: one required parameter, a clear dotted-key mechanism, and an output schema that can describe the return shape. Nothing essential for selecting or invoking this tool is missing.

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

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

Schema coverage is 0%, but the description compensates by explaining that the single 'key' parameter is a dotted path into config.yaml and provides a concrete example. This gives the agent enough semantic grounding to supply the parameter correctly.

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

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

The description states a specific verb ('Read') and a clear resource ('one config.yaml value by dotted key'), with an illustrative example. This cleanly distinguishes it from write-oriented siblings like config_set.

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

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

The usage context is implied rather than explicit: use this tool when you need to read a config value by key. It does not explicitly mention alternatives or when not to use it, though config_set is an obvious sibling counterpart.

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?

Despite no annotations being provided, the description proactively discloses important behaviors: it writes a .bak copy before changing the file, and it explains the type-safety reason (avoiding the YAML trap with 'off', 'no', 'yes'). This goes beyond a simple 'write' verb and gives the agent essential safety and side-effect information.

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 succinct, front-loads the core purpose in the first line, and then uses two short paragraphs to explain the value_type parameter and the .bak backup. Every sentence contributes meaning without waste, making it easy to scan.

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

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

Given the tool's simplicity (3 params, 2 required) and the presence of an output schema, the description is complete enough for an agent to call it correctly. It covers the critical type-safety caveat and the backup behavior, and the output schema likely clarifies return values, so nothing critical is missing.

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

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

The schema has 0% description coverage, so the description must compensate. It explains the purpose and allowed values of 'value_type' without using an enum, providing crucial semantics. It does not explain 'key' or 'value' beyond what their names imply, but the main ambiguity is covered.

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 writes one config.yaml value with an explicit type. It specifies the verb 'write', the resource 'config.yaml value', and the distinguishing feature 'explicit type', which differentiates it from config_get and other sibling tools.

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

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

The description explains when to use this tool (to avoid YAML type coercion) and warns against relying on auto-parsed values, suggesting a clear context for use. It does not explicitly name alternatives, but the sibling list includes config_get, so the usage is implicitly differentiated.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions that schedule accepts natural language, but it does not describe side effects, permission requirements, conflict behavior, or what happens after the job is created. This is thin for a mutating creation 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 compact and front-loaded: the core purpose appears first, followed by one useful clarification about schedule syntax. There is no filler or redundancy.

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

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

For a creation tool with four parameters and no annotations, the description is incomplete. It omits what name/prompt/deliver mean, how schedule conflicts are handled, and what the response contains. The schedule-format note is helpful but not enough to make the tool safely callable without further assumptions.

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 explaining parameters. It only clarifies the schedule parameter by saying it accepts Hermes CLI-style natural language; name, prompt, and deliver remain unexplained beyond their bare titles. This is insufficient for three of the four 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 states a specific verb and resource: 'Create a scheduled job.' The verb 'create' clearly distinguishes this from sibling tools like cron_edit, cron_list, and cron_run. Even though it doesn't name siblings, the action is unambiguous.

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

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

The description does not explicitly say when to use this tool versus alternatives such as cron_edit or cron_list. It only states the tool's purpose and gives a hint about schedule formatting, leaving the agent to infer usage from 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?

With no annotations, the description carries the burden of behavioral disclosure. It discloses the important non-destructive trait that the job id and run history are preserved during edits. However, it does not mention side effects, permission requirements, how omitted or null parameters are interpreted, or whether changes take effect immediately—leaving significant behavioral gaps.

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

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

The description is a single efficient sentence that front-loads the core action and the key preservation guarantee. It wastes no words, though it could have included minimal parameter context without losing conciseness.

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 5 parameters, 0% schema description coverage, and no annotations, this one-line description is incomplete. It leaves unspecified which fields can be edited, how null values behave, required parameters beyond job_id, and any interaction with cron_run or cron_list. The presence of an output schema does not compensate for these missing usage semantics.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meaning, but it adds none. It does not mention job_id, model, prompt, schedule, reasoning_effort, or the semantics of null versus omitted fields. An agent cannot infer how to compose the request from the description alone.

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

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

The description uses a specific verb ('Change'), a specific resource ('scheduled job'), and the crucial qualifier 'in place, keeping its id and run history,' which clearly distinguishes it from cron_create. An agent can immediately tell this is an edit operation on an existing job rather than creation or listing.

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 'Change a scheduled job in place' implies this is for modifying an existing job, and 'keeping its id and run history' suggests it is not the tool for creating new jobs. However, it does not explicitly name alternatives like cron_create or state conditions for when not to use it, so it stops short of full 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 burden of disclosing behavior. The word 'List' implies a read-only, non-mutating operation, which is adequate for a simple listing tool. However, it does not disclose whether jobs are scoped to the current user, whether authentication is required, or any rate/volume limits – context that could matter in practice.

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

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

The description is a single sentence of nine words, front-loaded with the action verb and resource, with zero extraneous content. Every word earns its place.

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

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

For a zero-parameter tool with an output schema, the description fully covers the tool's purpose and the intended return content. The output schema handles return value details, so nothing an agent needs to select and invoke the tool correctly is missing.

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

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

The tool has zero parameters, so the schema is trivially complete (100% coverage). Per the baseline for 0-parameter tools, a score of 4 is appropriate; the description adds no parameter semantics, but none are needed.

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

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

The description uses a specific verb ('List') and a precise resource ('scheduled jobs') with the output fields (schedules, next run times). It clearly distinguishes cron_list from siblings like cron_create, cron_edit, and cron_runs, which would be used to create, modify, or list run history respectively.

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

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

Usage is implied by the verb and resource: an agent can infer to call this when it needs to see scheduled jobs. However, there is no explicit mention of when not to use it or how it differs from cron_runs, leaving the routing to inference rather than direct guidance.

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

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

With no annotations, the description carries the full burden and does disclose key behavior: the action queues a run rather than executing immediately, and it happens on the next scheduler tick. It makes the asynchronous nature clear, though it omits details about idempotency or error conditions, which is minor for a one-action 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?

A single, front-loaded sentence that contains no filler. Every word contributes to conveying the action, target, and timing.

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

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

For a one-parameter tool with an output schema present, the description covers the action and timing adequately. It misses a note that the job must already exist, but this is a minor gap 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?

Schema coverage is 0%, but there is only one parameter, job_id, and the description's 'a job' makes the mapping apparent. It does not add explicit detail about where to obtain the ID or its expected format, but the context is sufficient for a simple 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 uses a specific verb 'Queue' with a clear resource 'a job' and the timing constraint 'on the next scheduler tick instead of waiting.' This cleanly distinguishes it from siblings like cron_create (scheduling) and cron_runs (listing runs).

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 'instead of waiting' implies this is for triggering a job before its scheduled time, but it does not explicitly state when to use this versus alternatives like cron_create or cron_edit. No exclusions or alternative tool names are provided.

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

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

With no annotations provided, the description carries the full burden. It states the read-only nature ('Show') and the ordering behavior, but does not mention any side effects, auth requirements, or limitations (e.g., scope of records). It adds some behavior context but not rich detail.

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 short sentence that front-loads the action and ordering. No wasted words.

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

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

The tool has one optional parameter and an output schema, so the description is short. However, since the only parameter's semantics are undocumented in both schema and description, the definition is incomplete for agents trying to call it correctly. It also doesn't specify scope of 'execution attempts' (e.g., all jobs or default filter).

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

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

The schema has no description for job_id (0% coverage). The description does not mention job_id at all, leaving agents to guess whether it is a filter, an identifier, or otherwise. The description fails to compensate for the missing schema documentation.

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 ('Show') and resource ('recorded execution attempts'), with an ordering qualifier ('newest first'). It clearly distinguishes this from sibling tools like cron_list (listing cron jobs) and cron_run (triggering executions).

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 its use when execution history is needed, but does not explicitly contrast with alternatives like cron_list or cron_run, nor state conditions for choosing this tool over them. No when-not or alternative guidance.

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

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

No annotations are provided, so the description carries the burden. It discloses that the tool runs a command and returns a report, which is a read-only operation. However, it doesn't mention potential side effects, execution time, or what happens if the command fails. The description 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 sentence that is direct and front-loaded. It states the command and the output in minimal words with no 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?

For a zero-parameter tool with an output schema, the description is fairly complete. It tells the agent what command runs and what it returns. It could mention whether this is safe/read-only, but the absence of parameters and the presence of an output schema reduce the need for more.

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 doesn't need to explain parameter semantics. The baseline for 0 params is 4, and the description correctly implies no inputs are needed.

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

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

The description clearly states the action ('Run `hermes doctor`') and the resource ('its health report'), which distinguishes it from sibling tools like hermes_status and hermes_ask. It is specific about what the tool does, though it doesn't explicitly differentiate it from hermes_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?

The description implies usage: run this when you need a health report from hermes. It doesn't explicitly state when to use this over hermes_status or other sibling tools, but the context of 'health report' provides some guidance.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavioral traits. It states the action ('restart') and purpose, but does not mention anticipated side effects such as dropped connections, service downtime, required permissions, or whether the operation is reversible. This is a notable gap for a potentially disruptive operation.

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

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

The description is a single, focused sentence with no filler or redundant information. It front-loads the action and immediately provides the purpose, earning a top score for conciseness.

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

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

Given the tool has no parameters and an output schema exists, the description is mostly complete for basic invocation. However, it lacks explicit context about operational impact or prerequisites (e.g., that restarting will interrupt active messaging sessions). This makes it minimally viable but not fully comprehensive.

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

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

The tool has zero parameters and an empty input schema, so there is no parameter semantics to add. With no parameters, the baseline of 4 applies; the description need not explain parameter meaning.

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

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

The description uses a specific verb and resource: 'Restart the messaging gateway.' It also gives a clear reason, 'so configuration changes take effect.' It does not explicitly differentiate from siblings like gateway_status, but the action is unambiguous.

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

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

The phrase 'so configuration changes take effect' provides a clear context for when to use this tool: after configuration updates. It does not explicitly state when not to use it or name alternatives, but the intended scenario is sufficiently 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?

With no annotations, the description carries the full burden, and 'show whether' clearly signals a read-only status query with no mutation. It also discloses the specific behavioral output concept ('running and supervised'), which is meaningful beyond a generic status label.

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 scoped sentence with no filler. The key information—what is shown and about which resource—is front-loaded and directly actionable.

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 status tool with an output schema present, the description provides adequate context: it names the resource and the exact state dimensions reported. No additional invocation nuance appears necessary for an agent to call this tool correctly.

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

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

The tool has zero parameters, so the schema is trivially complete and the description has no parameter burden. The baseline of 4 applies because there is nothing for the description to add about inputs.

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 ('show') and a specific resource ('messaging gateway') with precise outcome semantics ('running and supervised'). This clearly distinguishes it from siblings like gateway_restart and hermes_status based on wording alone.

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

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

The description implies the tool is for checking gateway state, but it does not state when to prefer it over similar siblings such as hermes_status or doctor, nor does it mention any exclusions or alternative conditions. Usage context is inferred rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that the execution is non-interactive and can invoke 'the agent's own tools, skills and memory,' implying possible side effects. It does not explain permission needs, timeout behavior, or the risk that the agent may perform arbitrary actions through its tools.

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 short sentences with no filler: purpose first, execution mode second, usage guidance third. Every sentence contributes new information beyond what the schema or annotations already provide.

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 to be described. However, since annotations are absent and the schema leaves model and timeout_seconds opaque, the description does not fully cover execution configuration or the side-effect potential of an agent that can use tools. It is adequate for a simple prompt-only call but incomplete for a powerful agent-execution 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 must compensate. It only gives meaning to the prompt parameter by calling it 'a task.' The optional model and timeout_seconds parameters receive no explanation, leaving an agent unable to reason about when or how to set them.

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

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

The description clearly states the action and resource: 'Give the Hermes agent a task and return its reply.' It also clarifies the mode as 'one non-interactive turn with the agent's own tools, skills and memory.' However, it does not name a specific sibling or explain how this differs from general-purpose siblings like shell or cron_run, only broadly separating 'inspection and config' 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 gives an explicit when-to-use signal: 'Use this for work; use the specific tools below for inspection and config.' This is clear context, but it is high-level and does not spell out when to choose this over shell or cron tools, which could also be used for work.

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 burden. It discloses that the tool reports configuration and CLI health, which implies a read-only, non-destructive behavior. However, it does not disclose whether the tool performs any checks that could have side effects, how long it might take, or what the output structure looks like. The description adds some behavioral context but not rich detail.

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

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

The description is a single sentence that front-loads the verb and resource. Every word earns its place, and it is appropriately sized for a zero-parameter status tool.

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

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

For a zero-parameter status tool with an output schema present, the description is largely complete. It tells the agent what the tool reports. It could mention that the output schema describes the result, but that is already available structurally. The only minor gap is not explicitly stating that this is a safe read-only operation, but the description's wording strongly implies it.

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

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

The tool has zero parameters, so the schema is trivially complete. The description adds meaning by explaining what the tool reports (configuration and CLI health), which is the only semantic content an agent needs. Baseline 4 for zero-param tools is 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 states a specific verb ('Report') and resource ('how this server is configured and whether the Hermes CLI answers'). It clearly distinguishes this from sibling tools like hermes_ask, doctor, and gateway_status by focusing on server configuration and CLI health. It could be slightly more explicit about the 'status' nature, but it is clear and not a tautology.

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 diagnostic/health-check usage context but does not explicitly state when to use this tool versus alternatives like doctor or gateway_status. It says what it reports but not when an agent should prefer it over siblings. This is adequate but leaves the routing decision to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It clearly implies a read-only operation via 'Show' and names the information returned, but it does not mention authentication needs, failure behavior, or the significance of 'Nous Portal status.'

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the tool's purpose and output 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 zero-parameter read-only informational tool, the description is largely complete. The output schema provides the expected return structure, and the description names the key result areas; however, it could clarify what 'Nous Portal status' encompasses.

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. There is no parameter information needed from the description; the empty schema already conveys that no arguments are required.

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 ('Show') and identifies clear resources: the configured default model, provider, and Nous Portal status. It is specific enough to differentiate from many siblings like config_get or doctor, though it does not explicitly contrast with the status-related siblings such as gateway_status or hermes_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 guidance on when to use this tool versus alternatives like gateway_status or hermes_status. The description states what it does but gives no context about selection criteria, prerequisites, or exclusions.

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

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

With no annotations, the description carries the behavioral disclosure burden. It conveys that the tool returns recent sessions and implies a read-only listing, but it does not specify ordering, time window, pagination behavior, or whether any side effects occur. This is adequate for a simple list tool but not richly transparent.

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

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

The description is a single, front-loaded sentence with no filler. The purpose clause adds value rather than redundancy, making it both concise and structured effectively.

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 one optional parameter and an output schema, the description is nearly complete. It states the resource, purpose, and recency constraint. Minor gaps remain around what 'recent' means and how limit behaves, but these are not critical given the simple interface and available output schema.

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

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

The single parameter, limit, has no schema description and the tool description does not mention it at all. The parameter name and default value are self-explanatory, but the description adds no meaning beyond the schema, and schema coverage is 0%.

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

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

The description uses a specific verb ('List'), a clear resource ('recent sessions'), and states the intended purpose ('so you can resume or inspect one'). It clearly distinguishes this tool from sibling list tools like cron_list and skills_list by naming the resource and user goal.

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 'so you can resume or inspect one' provides clear context for when to use the tool. However, it does not explicitly mention alternatives or when not to use it, though the resource and purpose are sufficient to infer typical usage.

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

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

With no annotations provided, the description carries the full burden. It discloses the environment-variable gate and that this executes commands on the host. It does not warn about potential destructive side effects or describe how results are returned, which would matter for a shell tool.

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

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

Two short sentences with the main action first and the critical configuration constraint second. No filler or repetition; both sentences add 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 description covers purpose and prerequisite but omits operational details such as timeouts, safety implications, and what happens on non-zero exit codes. Because an output schema exists, return format is covered elsewhere, but for a command-execution tool more risk and behavior context would make this definition complete.

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

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

Schema description coverage is 0%, and the description adds no explanation of 'command' or 'timeout_seconds'. The names are somewhat self-evident, but there is no guidance on timeout behavior, defaults, or how the command is interpreted. The description does not compensate for the schema's silence.

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?

Description says exactly what the tool does: 'Run a shell command on the Hermes host.' The verb and resource are specific and distinct from all sibling tools, so an agent can immediately tell this is the arbitrary-command execution 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?

The description gives clear context: intended for agents that have no terminal of their own, plus a prerequisite condition (HERMES_MCP_ALLOW_SHELL=1). It doesn't explicitly name alternatives or state when not to use it, but the guidance is strong enough for basic routing.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds useful context about the output format (category, source, enabled state), but does not mention any potential side effects, prerequisites, or error conditions, though listing is inherently read-only and low-risk.

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

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

The description is a single, front-loaded sentence that states the action, resource, and output fields with zero redundancy. Every word earns its place.

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

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

For a zero-parameter list tool with an output schema, the description is adequate. It identifies what is listed and the key attributes returned. It could add a note about scope ('all' installed skills) but that is largely implied by the verb 'list'.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description's mention of output fields adds some semantic context, but with no parameters there is little to clarify beyond what the schema already defines.

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

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

The description uses a specific verb ('list') and resource ('installed skills') and enumerates the output fields (category, source, enabled state), making the tool's function unmistakable. It also differentiates from sibling list tools like cron_list or sessions_list because it uniquely targets the skills resource.

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

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

No guidance is provided on when to choose this tool over alternatives or when not to use it. The description simply states what it does, leaving the agent to infer the appropriate context from the name and sibling tools.

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