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

With no annotations available, the description carries the full burden of behavioral disclosure. It only states the operation and provides no detail on side effects, error behavior, required setup, or whether the agent must exist.

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

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

A single front-loaded sentence with no filler. Every word carries meaning, and the structure is as tight as possible for the information included.

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 read tool, the description is minimally viable: an agent can infer that it should pass an agent_id and receive status. However, there is no output schema and no description of return values, status vocabulary, or error cases, so it is not fully complete.

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

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

Schema description coverage is 0%, and the description does not explain agent_id beyond 'an agent'. It adds no information about the expected format, source, or valid values, so it fails to compensate for the low schema coverage.

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

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

The description states a clear verb-resource pair: 'get' the 'status of an agent'. It distinguishes from task_status at the resource level, though it does not explicitly contrast with 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?

There is no guidance on when to prefer this tool over task_status or when an agent_id is available or required. No prerequisites or exclusions are mentioned, so the agent must infer usage entirely from the tool name.

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 mentions the tool aggregates results and includes specific fields, but doesn't disclose whether this is a read-only operation, whether it has side effects, what happens if tasks are missing, or how results are returned. The description adds minimal behavioral context beyond the basic action.

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 with no wasted words. It front-loads the action ('Aggregate results') and lists the included fields. It is appropriately concise, though it could have used the space to add more behavioral or usage context.

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 1 parameter with 0% schema coverage, no output schema, and no annotations, the description is incomplete. It doesn't explain the parameter structure, the return format, or how this differs from task_status/task_result. An agent would struggle to construct a correct call without opening the schema and guessing at the semantics of agent_id and task_id.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'tasks' parameter. The description says it aggregates results for multiple tasks, which implies the 'tasks' parameter identifies which tasks, but it doesn't explain the structure (array of objects with agent_id and task_id) or the meaning of those fields. The description adds some context but doesn't fully compensate for the 0% schema coverage.

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 ('Aggregate') and resource ('results for multiple tasks'), and mentions the fields included ('missing_tools, status and output'). However, it doesn't clearly distinguish this from sibling tools like task_status or task_result, which also deal with task results. The purpose is understandable but the differentiation from siblings is weak.

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 use this tool versus alternatives like task_status or task_result. The description doesn't mention any context, prerequisites, or exclusions. An agent would have to infer usage from the name and description alone, which is insufficient given the overlapping sibling tools.

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 reveals that the operation is asynchronous, returns an immediate task_id, and that progress tracking must be done separately. Some details are missing (e.g., error behavior, failure modes, prerequisites), but the key behavioral trait is clearly disclosed.

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 only two sentences, with the core operation and return behavior front-loaded. Every sentence contributes useful information, and it ends with a practical follow-up instruction. No fluff or redundancy.

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

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

The description covers the essential async contract and points to the right tracking tools, but given no annotations, no output schema, and zero parameter documentation, an agent still lacks enough detail about the optional parameters and edge cases to use the tool fully confidently. The basic call is clear, but richer context would be needed for optional fields.

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

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

The schema has 0% description coverage for its four parameters, and the description only loosely implies the meaning of agent_id and task by naming them in prose. The optional 'tools' and 'max_iterations' parameters are left unexplained in both the schema and description, so an agent cannot fully understand what values are expected.

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

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

The description states a clear verb and resource ('Assign a task to an agent') and communicates the asynchronous nature. It does not explicitly differentiate from sibling tools like spawn_agent, but the core purpose is specific and unambiguous enough for an agent to grasp the 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 description provides a concrete usage pattern: call this to start an async task, receive a task_id, and then use task_status/task_result to monitor. However, it does not explicitly state when to choose this over alternatives such as spawn_agent or broadcast, so some context is left 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 provided, the description must carry the behavioral burden. It discloses that execution is parallel and that the return value is a list of {agent_id, task_id}, which is useful. However, it does not mention whether the call blocks, whether delivery is acknowledged or guaranteed, or how failures with no running agents are handled—these remain unclear.

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 with no redundant wording. It front-loads the key action and scope, then immediately gives the return shape. 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 one-parameter tool with no output schema, the description includes the essential return information and clarifies the parallel dispatch behavior. However, it omits edge cases such as behavior when no agents are running, possible errors, or whether the message is processed asynchronously, leaving minor gaps for an agent invoking it in a complex workflow.

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. The single parameter 'message' is intuitively mapped by the phrase 'Send a message', but the description adds no detail about constraints, formatting, or requiredness beyond what the schema already states. Since the parameter is simple and self-explanatory, this is mildly adequate rather than fully compensating.

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 ('Send') and a clearly scoped resource ('a message to all running agents in parallel'), which distinguishes it from siblings like assign_task or write_storage. The parallel/broadcast behavior removes ambiguity about the tool's scope.

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 primary use case—messaging every running agent at once—but does not explicitly contrast it with alternatives like assign_task for single-agent communication or write_storage for persistent data. There is no exclusionary guidance, but the 'all running agents' phrasing gives moderate contextual direction.

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

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

The description implies a destructive action ('remove') but provides no detail on consequences, reversibility, impact on ongoing tasks, or safety. With no annotations, the description carries the full burden, and it fails to disclose potential side effects or prerequisites.

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, which is concise and front-loaded with the core action. However, it is too sparse, omitting essential context about the parameter and behavioral implications. It is not verbose but sacrifices completeness.

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

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

For a tool with one optional parameter and no output schema, the description should at least explain the meaning of 'old' and the parameter's role. It also does not address the effect on task-related tools (e.g., task_status, task_result). The description is incomplete for an agent to use it correctly.

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

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

The schema has one parameter, older_than_seconds, with no description (coverage 0%). The tool description does not mention this parameter at all, nor does it clarify how 'old' is determined. The meaning of the parameter is left entirely to its name, which is insufficient.

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 'Remove old tasks from history' with a specific resource (tasks) and distinguishes it from storage-related siblings like storage_cleanup. However, the term 'old' is undefined, leaving ambiguity about the criteria without consulting the parameter.

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

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

There is no guidance on when to use this tool versus alternatives, nor any context on appropriate invocation timing (e.g., periodic cleanup) or conditions. The description does not mention any related tools or scenarios.

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

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

No annotations are provided, so the description carries the full burden. 'List' clearly signals a read-only, non-mutating operation, and the description discloses the output content (status, busy flag, current task, task counts). It does not detail potential edge behaviors like ordering or pagination, but for a zero-parameter listing tool these are not significant 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, front-loaded sentence that conveys the action, scope, and return fields without any filler or repetition. Every word contributes useful 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?

With no output schema, the description appropriately lists what the returned data will contain, which is sufficient for an agent to interpret the result. The tool is simple (no parameters), so the description is complete enough for correct invocation, though it could briefly clarify 'managed agents' or task-count scope.

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 empty and no parameter semantics are needed. The 0-parameter baseline applies, and the description does not need to 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 states a specific verb ('List'), a specific resource ('all managed agents'), and the exact fields returned (status, busy flag, current task, task counts). It clearly differentiates from the singular-scope sibling 'agent_status' by emphasizing 'all managed agents'.

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 tells the agent what the tool does but gives no guidance on when to choose it over alternatives such as 'agent_status'. There are no explicit exclusions, prerequisites, or comparison to sibling tools, so the usage context is left entirely 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?

No annotations are provided, so the description carries the full burden. 'List all keys' clearly conveys a read-only enumeration behavior and the shared-storage scope, but it does not disclose potential edge cases such as pagination, ordering, or behavior with a large number of keys. Still, the operation is inherently non-destructive, which is evident from the wording.

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 detail. It states exactly what the tool does in the fewest words possible.

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, no-output-schema tool, the description is fully sufficient. 'List all keys in shared storage' tells an agent both what to expect as input and what the result will be, with no hidden prerequisites or complexity left unexplained.

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 there are no parameter semantics to explain. The schema already documents this completely with an empty properties object, matching the baseline for a no-parameter tool.

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 ('all keys in shared storage'), making the tool's purpose immediately clear. It implicitly distinguishes itself from read_storage by focusing on key enumeration rather than reading values, though it doesn't explicitly name an alternative.

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 intended use is implied: call this tool when you need to enumerate keys in shared storage. However, there is no explicit guidance on when to prefer this over read_storage or storage_cleanup, nor any exclusion criteria.

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

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

Annotations are absent, so the description must carry the full burden of behavioral disclosure. It states 'Read data', which implies a non-destructive operation, but it does not disclose what happens on a missing key, whether read-only behavior is guaranteed, or what the return format looks like. It adds no value beyond the obvious action, leaving the agent unaware of potential error handling or side effects.

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

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

The description is a single, short sentence that is front-loaded with the essential verb and resource. It is efficient and wastes no words. While it is minimal, it is appropriately concise for the simplicity of the tool, earning full marks for conciseness and structure.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description should still clarify the expected return value, error behavior, and how it relates to sibling tools. It does none of these. The agent has no indication of what to do with the result or how to handle missing data, making the description inadequate for safe and correct invocation.

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

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

Schema description coverage is 0%, and the tool description does not mention the 'key' parameter at all. The schema only indicates it is a required string, but does not explain its semantics, format, or purpose. The agent is left to guess that 'key' identifies the data to read; no additional meaning is provided, failing to compensate for the schema's lack of 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 clearly states a specific action ('Read') on a specific resource ('shared storage'), which is distinct from the tool name. However, it does not explicitly differentiate from siblings like list_storage, which could also involve reading storage-level data. The verb and resource are clear enough for an agent to infer the basic purpose, but the lack of a mention of 'by key' or 'specific item' leaves room for ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, exclusions, or the existence of list_storage, write_storage, or storage_cleanup. An agent has no explicit information about when read_storage is the right choice compared to listing storage contents or cleaning it up. The absence of any usage context forces the agent to rely solely on the name and schema.

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 only mentions the action and inputs, but does not explain side effects (e.g., whether an agent is immediately active), resource implications, required permissions, or what happens on failure. For a creation tool this is a significant transparency 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?

The description is a single, grammatically simple sentence with no filler words. It front-loads the primary verb and object. It is appropriately concise, though it could have used the brevity to include a hint about return values or lifecycle without becoming verbose.

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 there is no output schema and no annotations, the description leaves key operational details unstated: what the tool returns (presumably an agent identifier needed for later sibling calls), how the spawned agent is managed afterward, and any constraints on role_name or system_prompt. An agent cannot fully infer invocation success criteria or follow-up steps from this description alone.

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 three parameters. The description adds no meaning beyond restating 'role' and 'system prompt' from the schema; the 'tools' parameter is left entirely to the schema. This meets the baseline for full coverage but does not exceed it.

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 the specific verb 'spawn' and identifies the resource ('new agent'), plus the two key inputs (role and system prompt). This clearly distinguishes it from sibling tools like list_agents, stop_agent, and agent_status, though it does not explicitly name any alternative or contrast itself with them.

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

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

No guidance is provided about when to use this tool versus alternatives, nor any conditions, prerequisites, or exclusions. The description simply states what it does without addressing the decision context among the many sibling tools.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the high-level action without mentioning side effects, graceful vs. forceful termination, reversibility, required permissions, or error/return behavior. For a mutation tool, this is a significant 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?

The description is a single sentence with zero wasted words, front-loaded with the action and resource. Every word earns its place, making it highly concise and well-structured.

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 low complexity (one required param, no output schema), so the description is minimally adequate for a basic call. However, it omits important context such as behavior for non-running agents, return values, or prerequisites like checking status first, leaving it incomplete for robust use.

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

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

The input schema fully documents the single parameter agent_id with a clear description ('ID of the agent'), giving full schema_description_coverage. The tool description adds no additional meaning beyond this, 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 'Stop a running agent' uses a specific verb and resource, clearly identifying the tool's function. It is distinct from siblings like spawn_agent and agent_status, though it does not explicitly name them for differentiation.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as agent_status or spawn_agent. The phrase 'Stop a running agent' implies usage when an agent should be terminated, but no when-not conditions or alternative references 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?

There are no annotations, so the description carries the full burden of disclosing behavioral traits. It says 'Remove keys,' implying a destructive operation, but it does not state whether deletion is permanent, whether there are safety guards, what permissions are required, or what happens when the exclude parameter is supplied. The vague 'optional exclusion' adds little behavioral clarity.

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 the core meaning, and the destructive action is stated first.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It omits irreversibility, permission requirements, return values, and the precise interaction between pattern and exclude. An agent would need to guess at important behavioral details before invoking this 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 does explain that 'pattern' is a glob pattern and hints that 'exclude' is optional, but it does not clarify the exclusion semantics, precedence, or whether both parameters use the same glob format. It adds some meaning but leaves important details unresolved.

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 ('Remove keys from storage'), the resource (storage), and the selection mechanism (glob pattern with optional exclusion). This distinguishes it from sibling tools like read_storage, write_storage, and cleanup_task_history without needing to inspect the schema.

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: use this tool when you want to delete storage keys matching a pattern. It does not explicitly mention alternatives or when-not-to-use scenarios, but the resource and action are self-evident enough to guide selection among the listed siblings.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals one important edge case ('If task_id is omitted, returns the last result') and the read-oriented verb 'Get' implies a non-mutating operation. It does not cover error cases, what happens when no task exists, or how 'last result' is scoped (e.g., per agent).

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 two sentences with zero filler. The main purpose is front-loaded in the first sentence for immediate understanding, and the second sentence adds a concise edge-case behavior. 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?

Given there is no output schema, no annotations, and minimal parameter documentation, the description covers the returned content ('result ... enriched with task_id and status') and one edge case, but it leaves the required agent_id semantics unstated and provides no error or empty-result behavior. For a simple getter this is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate for both properties. It partially explains task_id by stating the omission behavior, but the required agent_id parameter is completely undocumented in text, leaving its purpose and relationship to task_id ambiguous. This is a significant gap.

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

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

The description states a specific verb and resource: 'Get the result of a task', and adds distinctive detail through 'enriched with task_id and status' and the fallback-to-last-result behavior. It implicitly differentiates from sibling task_status by focusing on the result rather than status alone, though it never explicitly names an alternative.

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

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

The description provides a clear conditional usage note for the task_id parameter ('If omitted, returns the last result'), which is useful context. However, it does not offer any guidance on when to choose this tool over siblings like task_status or aggregate_results, nor any exclusions for when not to use it.

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

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

There are no annotations, so the description carries the full burden. 'Get' implies a read operation, but the description does not state side-effect behavior, required ownership of the task, error conditions, or whether the task must belong to the supplied agent_id. This is a meaningful transparency gap for a tool with no annotation support.

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 operation and names the key output fields. There is no wasted wording or redundant restating 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 simple two-parameter status tool, the description names the key returned fields and identifies the resource. However, with no output schema and no annotations, it leaves out parameter semantics, error behavior, and how agent_id scopes the task lookup, so completeness is only moderate.

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 only mentions a 'specific task' without explaining the role of agent_id or the expected format/scope of task_id. The parameter names are somewhat self-explanatory, but the description does not compensate for the lack of schema-level 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 ('Get') and resource ('detailed status of a specific task'), and lists distinguishing fields like missing_tools, partial flag, and timestamps. This clearly separates it from siblings such as agent_status and task_result.

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

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

No guidance is given about when to use this tool versus task_result or agent_status, and no conditions or exclusions are mentioned. The description implies a status lookup but does not help the agent choose between related tools.

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 transparency burden. It adds useful behavior by saying JSON strings are handled automatically and protected keys are restricted, but it does not disclose overwrite behavior, failure behavior, permissions, or what happens when a protected key is used.

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 two short sentences with the core action front-loaded. There is no padding, and both sentences earn their place.

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

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

For a simple two-parameter write tool, this covers the core operation, JSON handling, and the protected-key constraint. It is still incomplete for safe invocation because it omits what protected keys are, how to format the value, and what happens on error or overwrite.

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 and the description must compensate. It implies the value can be a JSON string but does not explain key uniqueness, namespacing, value formatting, length limits, or how protected keys are identified.

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-resource pairing ('Write data to shared storage'), and the action is unmistakable. Mentioning JSON-string handling and protected-key restrictions also helps distinguish it from read_storage and storage_cleanup.

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

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

No guidance is given about when to use this tool versus siblings such as read_storage or storage_cleanup. The protected-key note hints at a limitation but is not a practical when-to-use or when-not-to-use instruction.

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