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

With no annotations, the description must carry the behavior burden. It discloses the auth requirement and expands the status codes into human-readable meanings Description-cropped. However, it does not state read-only behavior, default filter behavior when status is omitted, or pagination/response expectations, leaving meaningful 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?

Two sentences deliver scope, auth, and parameter semantics with no filler. Information is front-loaded and each clause earns its place.

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

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

For a simple optional-parameter list endpoint, the description covers the essential call context: scope, auth, and status values. But with no output schema and no sibling differentiation, it omits return-shape expectations and fails to explain how this listing differs from epf_download_list, so completeness is only adequate.

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 only parameter, status, is fully explained with enum meaning annotations (N=new, S=started, X=cancelled, C=completed), compensating for the 0% schema coverage. It also states the filter is optional. No further parameter behavior is described, but the single parameter is well 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 action (list), the resource (ACS-keyed download files), and the scope (productId=PARENT). It doesn't explicitly contrast with sibling tools like epf_download_list, and the term

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 specifies that Bearer auth is required and that status filtering is optional, but gives no guidance on when to choose this tool over sibling alternatives such as epf_download_list or epf_update_status. A clear selection condition is missing.

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

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

Since no annotations are provided, the description carries the full burden of behavioral disclosure. It reveals a critical behavioral trait: bytes never enter the LLM context, and it streams to a specific directory (EPF_DOWNLOAD_DIR). This goes beyond a basic description and helps the agent understand side effects and limitations. However, it does not cover error handling, authentication requirements, or potential overwrite behavior.

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 no wasted words. It front-loads the core action and result, then adds the critical behavioral note about bytes never entering context. Every sentence adds value.

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 explains the primary purpose and the return metadata, but it omits how to obtain a valid fileId, whether authentication is required (given sibling epf_login), and what happens on error or missing file. With only one parameter and no output schema, the description should provide more contextual guidance for correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate by explaining the parameter. The description does not mention 'fileId' at all, nor does it explain what it represents or how to obtain it. The only clue is the schema's pattern, which is technical. An agent would have to infer that fileId identifies the EPF file to download. This is a significant gap for a single-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 clearly states the action: 'Stream a binary EPF file to EPF_DOWNLOAD_DIR' and the outcome: return metadata only (path, content-type, byteLength, sha256). This is a specific verb and resource that distinguishes it from sibling tools like epf_download_list, which likely lists available files.

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 state when to use this tool versus alternatives, nor does it mention any prerequisites (e.g., being logged in via epf_login). It implies the tool is for downloading a specific file by ID, but there is no guidance on how to obtain a fileId or when to prefer other tools. No exclusions are given.

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

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

With no annotations, the description carries the full burden. It usefully discloses Bearer auth and the meaning of status codes (N=new, S=started, X=cancelled, C=completed), but it does not describe the return format, pagination behavior, or what happens when the status filter is omitted. This is adequate but leaves 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?

Two tight sentences with no filler. The core scope is front-loaded, the auth requirement is stated plainly, and the status filter is packed into a compact inline list.

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

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

The tool is simple: one optional parameter and no output schema, so the burden of explaining return values falls on the description. It covers purpose, auth, and filtering, but not what the returned list looks like or whether pagination/ordering applies. Without an output schema, that is a meaningful omission.

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 add meaning beyond the schema. It does so by decoding the status enum values and stating that filtering is optional. It does not mention the default behavior when no status is supplied, but it meaningfully compensates for the schema's lack of 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 states a specific verb ('List'), a clear resource ('EPF download files'), and an explicit scope ('productId=PARENT'). This distinguishes it from siblings like epf_download_epf_file, which downloads, and epf_update_status, which updates.

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 listing use case by naming the resource and optional status filter, and it correctly notes the Bearer auth requirement. However, it never explicitly says when to prefer this tool over alternatives such as epf_download_epf_file or epf_update_status, nor does it provide 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 full burden. It discloses that authentication produces a JWT and that store=true makes that JWT the active session credential, which are important behavioral side effects. It does not describe failure behavior, but for a simple auth call the key state-changing effect is covered.

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, front-loaded with the core action and followed by the optional parameter behavior. Every word adds value and there is no 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 three-parameter authentication tool with no output schema, the description covers the main action and the key session-storing side effect. It lacks guidance on error cases and does not position login relative to epf_reauth, which leaves some contextual gap for an agent.

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 maps login and pword to username/password and, more importantly, explains the store parameter's meaning beyond its boolean name: it controls whether the resulting JWT becomes the active session credential.

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 ('Authenticate') and names the resource ('EPF'), making the operation unmistakable. It clearly distinguishes this tool from siblings like epf_logout, epf_version, and epf_download_list.

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 states the tool is for authentication and explains the optional store parameter. However, it does not explicitly contrast login with epf_reauth or state when one should be used over the other, so usage guidance is only 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 does so well. It discloses the remote call, the local session cleanup, and the error state until reauthentication, giving the agent a clear picture of 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?

Two concise sentences, front-loading the action and immediately stating the post-condition. Every sentence contributes necessary information 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?

For a simple, parameterless logout tool, the description covers the server-side action, the local credential clearing, and the required follow-up (epf_reauth). Nothing needed to invoke or reason about the 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?

The tool has zero parameters and the schema confirms this, so no parameter documentation is needed. The description still covers invocation context completely, meriting the baseline for parameterless tools.

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 the exact endpoint ('EPF /logout') and the local action ('clear the local session credential'), making the tool's function unmistakable. It is clearly distinct from sibling authentication tools like epf_login and epf_reauth.

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

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

The description implies when to use the tool: to end an active EPF session. It also provides an important behavioral consequence ('Subsequent calls error until epf_reauth') that guides post-invocation steps, though it does not explicitly list alternatives or when not to use it.

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

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

No annotations are provided, so the description carries the transparency burden. It discloses the credentials source ('supplied at boot') and the practical trigger, but it does not explain side effects such as whether the previous session is invalidated or whether boot credentials failing produces an error. It 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 two tight sentences with no filler. The purpose is front-loaded, and the usage guidance follows immediately. Every word contributes either to purpose or to when to invoke it.

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 parameterless, side-effect-focused tool with no output schema, the description covers what the tool does and when to call it. It does not mention return values or error behavior, but given the low complexity and the presence of explicit usage triggers, it is nearly complete.

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

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

The tool has zero parameters)Skip; the schema provides no semantic burden. Because there are no parameters, the description cannot add parameter meaning; the high baseline for a parameterless tool applies, and the description's mention of 'credentials supplied at boot' conveniently explains why no parameters 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-plus-resource construction: 'Re-authenticate with the credentials supplied at boot.' This clearly distinguishes the tool from sibling tools like epf_login or epf_logout, since it specifically re-establishes an existing session rather than starting or ending one.

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

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

The description explicitly says when to use the tool: 'after a 401 error or before a known-stale batch.' This gives clear context for invocation executions, though it does not list exclusions or explicitly compare with epf_login, stopping short of full when/when-not coverage.

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 discloses that Bearer auth is required and defines the status codes, which is useful. However, it doesn't disclose side effects (e.g., whether updating to C triggers any post-processing, whether status changes are reversible, or what happens if a file is already in a terminal state). For a mutation tool with zero annotation coverage, 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 compact: two sentences plus a status legend. It front-loads the action and auth requirement, then packs the enum meanings efficiently. No wasted words, though the status legend could arguably be considered schema duplication since the enum values are already in the schema.

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 mutation tool with no annotations and no output schema, the description is thin. It tells the agent what statuses mean and that auth is required, but doesn't explain the expected outcome, error conditions, or whether this is part of a larger workflow (e.g., must be called after epf_download_epf_file). The sibling tools suggest a download lifecycle, but the description doesn't connect to 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?

Schema description coverage is 0%, so the description must compensate. It does explain the status enum values (N=new, S=download started, X=cancelled, C=completed), which adds meaning beyond the raw enum. However, it doesn't explain fileId semantics beyond the schema's minLength, and the description doesn't fully cover the parameter semantics for fileId. Baseline 3 is appropriate because the status explanation adds value but fileId remains underdocumented.

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 ('Update file status') and enumerates the status values, which distinguishes it from sibling tools like epf_download_list or epf_download_epf_file. It doesn't explicitly name a sibling, but the action is clear enough to differentiate.

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 context: it's for updating the status of a file in a download workflow, with statuses N/S/X/C mapping to lifecycle stages. It doesn't explicitly state when to use this vs alternatives, but the status enum and 'Bearer auth required' give some context. 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?

Since no annotations are provided, the description carries the full burden. It discloses a key behavioral trait: 'No auth required', which is useful for an agent to know before invoking. It also implicitly indicates a read-only operation (getting version info), and the description is transparent about the expected output (version and build date).

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, well-structured sentence that front-loads the action and resource, then adds the essential detail about authentication. It contains zero wasted words and is immediately understandable.

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, simple query tool with no output schema, the description is fully sufficient. It states what the tool returns (version and build date) and the auth requirement, leaving no gaps for an agent to call 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 tool has zero parameters, so the schema is empty. The description adds no parameter-specific information because none is needed; the baseline for 0 parameters is 4, and there is no coverage gap to compensate for.

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 'Get' and the resource 'EPF server version and build date', making the tool's purpose specific and unambiguous. It is distinct from all sibling tools, which focus on authentication, listing, downloading, or status updates, so there is no confusion.

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 by indicating what the tool does, but it does not explicitly mention when to use it versus alternatives or exclude other tools. However, given the tool's name and obvious purpose (version check), the usage is self-evident, and no explicit alternatives are needed.

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