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 the FS_READONLY requirement and recursive directory behavior. However, it does not mention whether an existing destination is overwritten, what happens on partial failure, or whether metadata is preserved, leaving notable 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 one tight sentence that front-loads the core operation and immediately adds the key modifier. No filler 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?

An output schema exists, so return values need less explanation. Yet as a mutating tool with no annotations, it lacks overwrite behavior, error semantics, and guidance distinguishing it from move, making the guidance incomplete for fully confident use.

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

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

Schema coverage is 0%, so the description must compensate; it adds meaning by explaining recursive=True controls directory copies and implies src/dst are paths. Still, it does not clarify destination semantics, path format, or any constraints 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?

States a specific verb-resource combination: 'Copy a file, or a directory if recursive=True.' This clearly distinguishes file vs. directory behavior. However, it does not explicitly differentiate from the sibling move tool, so it misses the strongest sibling distinction.

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

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

Provides a precondition ('Requires FS_READONLY=false') but no guidance about when to use copy versus move or other alternatives. There is no explanation of when copying is preferred over moving or searching.

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 of behavioral disclosure. It does reveal the destructive nature and the FS_READONLY requirement, and it clarifies recursive behavior. However, it does not state irreversibility, failure behavior for non-empty directories when recursive=false, or other error cases.

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

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

The description is extremely concise: two short sentences that each add necessary information. The core behavior is front-loaded, and the prerequisite is stated compactly without 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 simple two-parameter delete tool, the description covers the main behavior, the recursive edge case, and the required configuration flag. An output schema exists, so return values need not be explained. It could mention error behavior, but the essentials for invoking the tool correctly 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 0%, so the description must clarify parameters. It adds meaning to 'recursive' by specifying that it enables directory deletion. However, 'path' is left largely implicit as the file or directory to delete, with no additional guidance on formats or edge cases.

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

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

The description states a specific action ('Delete') and target ('a file, or a directory'), with the condition for directories ('if recursive=True'). It clearly identifies what the tool does, though it does not explicitly differentiate itself from sibling tools such as move or copy.

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

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

The description provides clear context: use it to delete files, or directories when recursive is true. It also gives a prerequisite ('Requires FS_READONLY=false'). It does not explicitly state when not to use it or name alternatives, but the purpose is unambiguous.

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 function without revealing behavior such as return values, error handling, permissions, or side effects. This is a significant gap for a simple tool that could behave in different ways.

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, clear sentence with no wasted words. It is appropriately brief for a simple tool, and the core action is front-loaded. 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?

The tool is simple but lacks context on return value and behavior. An output schema exists but is not described, and the description doesn't mention what the tool returns (presumably a boolean). Without annotations, this is insufficient for an agent to call it correctly and interpret the 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?

The schema has one required parameter 'path' with zero description coverage. The tool description does not explain what 'path' means, its format, or constraints (e.g., absolute or relative, file or directory). This leaves ambiguity about the expected input, and the description adds no clarity beyond the schema's type.

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 'check' and clearly identifies the resource as path existence. It is unambiguous and distinct from siblings like read_file or list_dir, which have different purposes. Even though it doesn't explicitly contrast with stat, the intent is clear and singular.

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 such as stat or list_dir. It simply states the function without context on when it is the right choice, leaving the agent to infer based on the tool name alone.

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

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

With no annotations, the description carries the behavioral burden. It conveys a read-only search behavior and gives a concrete glob example, but it does not disclose details such as recursion behavior, hidden-file handling, symlink following, or error semantics. It is not misleading, but it is minimally 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?

A single, front-loaded sentence with no filler. The action, target, example, and scope are all present, and every word contributes to understanding the 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 simple two-parameter search tool with an output schema, the description is largely complete. It tells the agent what to search, how (glob), and where (under path). Minor gaps like recursion or hidden-file behavior would be useful but are not critical for basic invocation.

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

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

Schema coverage is 0%, so the description must compensate for the schema's bare string fields. It does: 'pattern' is clarified as a glob pattern with an example, and 'path' is established as the base under which the search occurs. It does not mention the default path value, but the schema already provides that.

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

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

The description clearly states the action (search), the resource (files), and the scope (under path). It differentiates itself from siblings like list_dir by emphasizing glob pattern matching, though it does not explicitly name a sibling for contrast.

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 use case is implied: use this when you need to find files matching a glob pattern under a path. However, there is no explicit guidance about when to use this instead of list_dir, exists, or read_file, 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?

With no annotations provided, the description carries the behavioral disclosure burden. It does state that the tool lists entries with name, is_dir, size, and mtime, which is useful. However, it does not mention behavior for nonexistent paths, permissions, hidden files, or whether symbolic links are followed.

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 adds meaning: the operation, the target, and the output fields are all conveyed efficiently.

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 a simple interface (one optional parameter) and an output schema, so the description does not need to restate return types. The main missing piece is error behavior for invalid paths, which is a minor concern for a read-only listing 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 clarifies that 'path' refers to a directory, but it does not add details about accepted path formats, the default '.', or edge cases. The single self-descriptive 'path' parameter keeps this from being a critical 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 names a specific verb ('List') and a specific resource ('contents of a directory'), and specifies the returned fields (name, is_dir, size, mtime). This clearly differentiates it from siblings like read_file, stat, and glob_search, which serve different listing/metadata purposes.

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 it should be used when a directory's entries are needed, but it does not explicitly state when to prefer this tool over alternatives like glob_search or stat. There are no exclusions or alternative-routing hints 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, the description carries the burden of behavioral disclosure. It discloses a meaningful permission requirement, 'Requires FS_READONLY=false,' but does not explain what happens when the directory already exists or whether intermediate parents are created. The schema defaults hint at behavior, but the description itself is minimal.

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

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

The description is extremely short: two sentences with no filler. The core action comes first, followed by the permission constraint. It is concise, though it sacrifices valuable behavioral and parameter guidance.

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

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

Given an output schema exists and this is a simple tool, the description is minimally acceptable. It states what the tool does and the key permission requirement. However, it lacks context about default behavior for existing directories or parent creation, and the 0% parameter coverage leaves gaps that the description could have filled.

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

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

Schema description coverage is 0%, and the description does not compensate by explaining 'path', 'parents', or 'exist_ok'. While 'path' is somewhat obvious, the meaning and effect of 'parents' and 'exist_ok' are left entirely to inference from their 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 clearly states the action: 'Create a directory.' This is a specific verb plus resource and matches the tool name without ambiguity. It doesn't describe edge-case behavior, but the core purpose is unmistakable and distinct from the sibling file 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 a necessary precondition, 'Requires FS_READONLY=false,' which helps the agent know when this tool is allowed. However, it does not explicitly compare against alternatives like write_file or move, so when-to-use versus siblings is only implied by the 'mkdir' semantics.

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 disclosure burden. It does add one behavioral constraint, FS_READONLY=false, which signals that this is a mutating operation with an environment prerequisite. However, it does not disclose overwrite behavior or the fact that the source is removed after a successful move.

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 entire description is a single front-loaded sentence with no filler. Every phrase adds information: operation, resource, and a required configuration condition.

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 mutating filesystem tool with no annotations, the description leaves important call-time decisions unaddressed: overwrite semantics, destination-directory behavior, and relationship to copy. The output schema may cover return values, but the behavior gap remains significant.

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, but it does not explain src or dst beyond their names. The names are conventional, yet the description adds no semantics such as path types, relationships, or constraints.

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 ('Move/rename') and identifies the resource ('a file or directory'), so an agent can tell it is a relocation operation. It does not explicitly contrast with the sibling copy tool, but the semantics are clear enough.

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

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

It gives a prerequisite ('Requires FS_READONLY=false') but no guidance on when to choose move vs copy or how to treat an existing destination. No alternative tool is mentioned, so an agent must infer the usage context.

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

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

With no annotations, the description carries the full behavioral burden. It discloses meaningful traits: text decoding with errors replaced, binary output as base64, and a max_bytes cap to avoid flooding context. It does not cover failure modes or permissions, but the main behavioral surface is well described.

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?

Three sentences, with the core purpose front-loaded and each sentence earning its place. The formatting using backticked parameter names makes the guidance easy to scan, with no filler.

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 presence of an output schema covers return-value details, and the description covers the main input behaviors and the safety-motivated max_bytes cap. It is complete enough to call correctly, but lacks explicit sibling selection guidance and failure-behavior notes, so it stops short of a 5.

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 per-parameter descriptions, so the description must compensate. It explains the semantics of encoding (errors replaced), binary (raw bytes base64-encoded), and max_bytes (read cap), adding real meaning beyond the schema's types and defaults. Path is left implicit, but that is acceptable given the tool's clear purpose.

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

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

The description opens with "Read a file's contents," a specific verb+resource statement that clearly identifies what the tool does. It is clear enough to distinguish from siblings like write_file, list_dir, and stat, though it does not explicitly name or contrast them.

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

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

There is no guidance on when to choose read_file over alternatives such as stat, exists, or list_dir. The description explains parameter behaviors but does not provide explicit when-to-use or when-not-to-use context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It implies a read-only operation via 'Fetch', but it does not mention behavior on missing paths, symlink resolution, permission requirements, or whether an error is raised. These are meaningful gaps for a filesystem 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, direct sentence with no filler or redundancy. It front-loads the action and resource immediately, making it easy to scan. Nothing here 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?

Given a single required parameter and a present output schema, the description covers the basic invocation shape. However, it lacks usage context, error semantics, and path expectations, leaving an agent to guess about edge cases. It is minimally viable 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?

The schema has 0% description coverage, so the description needed to compensate, but it only restates the parameter name by saying 'for a path'. It adds no detail about absolute vs relative paths, file vs directory support, or formatting constraints. This is minimal semantic value beyond the schema's property name.

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 ('Fetch') and resource ('filesystem metadata') for a given path, which clearly distinguishes it from siblings like read_file, exists, and list_dir. It doesn't explicitly compare itself to those tools, but the core purpose is unmistakable. It loses one point for not specifying what metadata is returned.

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 stat versus alternatives like exists, read_file, or list_dir. The description merely states the operation without mentioning exclusions, prerequisites, or typical use cases. Sibling tool names imply some alternatives, but the description itself provides no routing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses the FS_READONLY prerequisite, but omits critical behavior such as whether the file is created, overwritten, or appended by default, and whether parent directories are created. 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?

Two short sentences with no wasted words. The main action is front-loaded and the prerequisite is stated separately. This is an appropriately concise description for its limited 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?

Despite having an output schema, the description remains incomplete for correct invocation. It does not explain path conventions, default overwrite behavior, append semantics, or encoding accepted values. For a write operation with four parameters and no annotations, more context is needed.

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, but it only glosses the content parameter as 'text content.' It adds no meaningful guidance for path, append, or encoding, leaving the agent to guess their semantics.

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: 'Write text content to a file.' It clearly differentiates write_file from sibling tools like read_file, move, copy, and delete by naming the exact action and target.

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: use this tool when writing text content to a file. The prerequisite 'Requires FS_READONLY=false' gives some operational context, but there is no explicit guidance on when to choose this over alternatives or when not to use it.

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