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 the tool creates a user via POST, which is useful, but it does not mention required permissions, side effects, idempotency, or response behavior beyond the existence of an output schema. It is adequate but leaves behavioral gaps.

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

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

Three concise sentences, front-loaded with the action, no filler. Each sentence contributes either the operation, the HTTP call, or parameter routing 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 the generic schema parameters and no annotations, the description provides a solid routing skeleton but not enough detail about the required JSON:API payload structure or any authentication prerequisites. The output schema may cover return values, but request construction still relies on external knowledge.

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 explicitly maps all three generic parameters: route IDs go in path_params, filtering/pagination/sorting/include values go in query, and the JSON:API payload goes in body. This adds real meaning beyond the generic schemas, though concrete field names are still absent.

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 ('Create') and resource ('administrator user'), and adds the exact HTTP call (`POST /users`). This distinguishes it clearly from sibling update/get/list/delete admin user 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 clear instructions on where to place parameters (path_params, query, body), so an agent knows how to invoke it. However, it does not explicitly compare it to alternatives such as update_admin_user or explain when to choose it over them; the usage context is implied by the verb and name rather than stated.

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?

Given there are no annotations, the description carries the burden of behavioral disclosure. It discloses that deletion is permanent and cites the HTTP DELETE method, indicating a destructive, non-reversible action. It also states where parameters go. However, it does not discuss permissions, side effects on related data, or error behavior, which would be expected for a destructive mutation with zero annotation coverage.

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 filler. The primary action and permanence are front-loaded ('Permanently delete an account'), followed by the HTTP call and parameter placement. Every word adds value, and the structure is efficient and scannable.

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 delete operation with an output schema present, the description is fairly complete. It covers the endpoint, permanence, and how to route parameters. It omits details like authentication requirements or what happens to associated resources, but given the tool's simplicity and the presence of an output schema, the description is adequate. It would benefit from noting that deletion is irreversible or listing any required permissions, but these are minor.

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 provide guidance: 'Put route IDs in path_params and filtering, pagination, sorting, or include values in query.' This clarifies the meaning of path_params (for IDs) and query (for filters/pagination/sorting), which is useful. However, the 'body' parameter is not mentioned at all, and the description does not detail value formats or examples, leaving a gap in full parameter 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 clearly states the operation: 'Permanently delete an account,' identifying the verb (delete) and resource (account). It also specifies the HTTP method and endpoint, making the purpose unambiguous. However, it does not differentiate from sibling tools (e.g., delete_admin_user) by explicitly naming alternatives, so it stops short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no warnings about destructive consequences beyond the word 'permanently.' It does not mention when not to use it or refer to any sibling tools, leaving usage context entirely implicit.

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 descriptions carrying full responsibility in the absence of annotations, this description partially delivers: 'Permanently delete' discloses irreversibility, and the endpoint plus param-placement rule adds operational clarity. However, it doesn't mention required permissions, side effects, or failure behavior for an irreversible mutation.

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 short and front-loaded with the core action, but the final sentence is awkwardly phrased and slightly ambiguous ('Put route IDs in query... and filtering...' could be misread). It contains a few useful details without fluff, but the phrasing hurts clarity.

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 an output schema, the description need not explain the return value. For a mutation tool, it covers the endpoint and param placement but omits documentation of the 'body' parameter and does not mention any prerequisites. It is enough for basic invocation but leaves unanswered questions about behavior on a delete.

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 provides no descriptions for any parameter (0% coverage), so the description must compensate. It does by mapping route IDs to path_params and filtering/pagination/sorting/includes to query, which adds real meaning beyond raw schema names. It still leaves the 'body' parameter unexplained, but the overall guidance is useful.

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 ('Permanently delete'), identifies the resource ('administrator user'), and provides the exact endpoint ('DELETE /users/{userId}'). This distinguishes it from siblings like create_admin_user, get_admin_user, and delete_account without needing to inspect their schemas.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives, no prerequisites, and no warnings about irreversible consequences. The only practical hint is where to place route IDs in the request, which is parameter placement rather than 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 provided, the description carries the full burden of behavioral disclosure. It clearly shows this is a GET operation and signals read-only behavior, and it explains where query values go. However, it avoids any mention of auth requirements, error behavior, 404 handling, or whether the call requires an existing account, so transparency 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 three tight sentences: purpose, endpoint, and parameter placement. There is no filler, the key facts are front-loaded, and each sentence 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 that an output schema exists and this is a simple GET-type retrieval, the description covers the necessary core: the operation, the endpoint, and where to put IDs and filters. It does not explicitly document the `body` parameter or state that the account ID is required, but those are fairly low-risk gaps because the endpoint template makes the ID requirement obvious.

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 schema itself is a generic set of nullable objects. The description adds real meaning by mapping `path_params` to route IDs and `query` to filtering, pagination, sorting, and include values. The `body` parameter is left unexplained, which prevents a top score, but the most useful parameter semantics are provided.

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

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

The description states a concrete verb and resource ('Get an account's details') and backs it with a specific endpoint, `GET /accounts/{accountId}`. This clearly distinguishes it from sibling tools like `list_accounts` and `get_account_summary_report`, even though those are not named.

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 useful context about how to construct the request ('Put route IDs in path_params...') but does not explicitly say when to choose this tool over alternatives such as `list_accounts` or `get_account_summary_report`. The intended use is inferable, but the description does not provide the when-to-use versus when-not-to guidance of a top-tier description.

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

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

With no annotations, the description carries the full behavioral disclosure burden. It discloses the HTTP method and endpoint, implying a read-only retrieval, but it does not state auth requirements, rate limits, or whether the path ID is effectively required despite the schema listing zero required parameters.

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 short sentences front-load the purpose, then the endpoint, then parameter placement. Every sentence contributes and there is no filler, though the phrasing 'or include values in query' is slightly awkward.

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?

Core request construction is covered and an output schema exists, so return-value documentation is not required. However, the description never explains the body parameter, does not explicitly name the required path key, and gives no bridge to the sibling list tools that would supply the report 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 coverage is 0% and the schema only provides untyped additionalProperties objects, so the description is the only real parameter documentation. It usefully assigns path_params to route IDs and query to filtering, pagination, sorting, and include values. It leaves body unexplained and does not enumerate exact query parameter names, but for a GET tool this is a modest 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?

States a specific verb ('Get') and resource ('account summary report') and gives the exact REST endpoint. It clearly targets a single report by ID and is visually distinct from sibling list tools like list_account_summary_reports, though it does not explicitly name 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?

Explains how to structure the call: path_params for route IDs and query for filtering, pagination, sorting, and include values. However, it does not say when to prefer this over list_account_summary_reports or list_account_summary_reports_for_account, nor mention prerequisites such as obtaining the report ID first.

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 only mentions that it calls a GET endpoint, which implies a read operation, but does not disclose any side effects, required permissions, error behaviors, or rate limits. It lacks details about what happens on success or failure, and does not clarify whether the tool is read-only beyond the HTTP method.

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 redundancy. The main purpose is front-loaded, followed by the HTTP call and parameter placement guidance. Every sentence contributes value, and there is no fluff. It is appropriately sized for the tool's simplicity.

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 an output schema, return values are covered. However, the description leaves gaps: it does not explain the body parameter, does not clarify that path_params likely requires a userId even though schema marks it optional, and does not mention any prerequisites or authentication. For a simple GET operation, it 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. It partially does by explaining that path_params holds route IDs and query holds filtering, pagination, sorting, or include values. However, it does not explain the body parameter at all, and the guidance for path_params is vague ('route IDs' without specifying which ID). This adds some meaning but is incomplete for a tool with three parameters.

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

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

The description clearly states the tool's purpose: 'Get administrator user details' and specifies the underlying HTTP call. It is specific about the verb and resource, though it does not explicitly differentiate from sibling tools like list_admin_users or get_account. The name and description align well, so the purpose is unambiguous but lacks 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?

The description implies usage: fetch a single admin user's details. It provides guidance on where to put parameters ('Put route IDs in path_params and filtering, pagination, sorting, or include values in query'), but does not explain when to choose this tool over alternatives like list_admin_users or get_account. There is no explicit when-not-to-use or alternative selection logic.

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 safety-transparency burden. It communicates a read-style operation through 'GET' and clarifies parameter placement, but it does not disclose authentication requirements, failure/404 behavior, or the fact that assignmentId is effectively required despite `path_params` being declared optional in the schema.

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 carry the endpoint and all essential parameter-placement rules with no filler. The key routing guidance is front-loaded after the one-line purpose, making it fast for an agent to parse.

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

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

This is a simple single-resource GET with an output schema to describe the return shape, so the description covers the main gaps: exact endpoint, path vs query routing, and supported query categories. It could be more complete by explicitly marking `assignmentId` as required and noting any auth prerequisites, but those are minor for this simple 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 coverage is 0% and all three parameters are untyped generic containers, so the description must do the work. It meaningfully says to place route IDs in `path_params` and filtering, pagination, sorting, and include values in `query`, which is exactly the disambiguation an agent needs. It leaves `body` unmentioned, but for a GET the body is likely irrelevant.

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 concrete operation ('Get assignment details') and gives the exact endpoint `GET /assignments/{assignmentId}`, which clearly identifies the resource and scope. This distinguishes it from sibling list/get tools such as `list_assignments` and `get_assignment_learner_activity` by pointing at the single assignment resource rather than a collection or sub-entity.

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 by the endpoint and name: call it when you need details for one assignment. However, it never says when *not* to use it or names an alternative (e.g., `list_assignments` for collections), so the usage guidance is inferred rather than explicit.

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

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

With no annotations, the description carries the behavioral burden. It discloses that this is a GET request, implying a read-only, non-destructive operation, and it reveals the endpoint structure. However, it does not mention authentication requirements, error behavior, or what happens when the certificate does not 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?

The description is only two sentences, front-loads the core purpose, and includes the endpoint plus parameter placement without unnecessary filler. Every sentence contributes 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?

For a simple GET tool with an output schema, the description provides the endpoint and the general split between path and query parameters. It is incomplete because it omits the exact route parameter name and does not clarify whether body should ever be used, creating potential confusion 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?

The schema provides zero property descriptions, so the description's guidance that route IDs belong in path_params and filtering/pagination/sorting/include values belong in query adds useful meaning. It does not, however, specify the exact path key such as assignmentId or explain how body is used, leaving meaningful ambiguity.

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 ('Get') and a specific resource ('a learner's assignment completion certificate'), and it names the exact endpoint. It is clear and unlikely to be confused with siblings, though it does not explicitly differentiate itself from similar assignment-related getters.

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 mechanical guidance about putting route IDs in path_params and query values in query, but it does not explain when to use this tool versus alternatives such as get_assignment or get_assignment_learner_activity. No context about prerequisites, typical use cases, or exclusions is 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. It does disclose that the operation is a GET and which parameters go into the path vs. query, implying a read operation, but it does not mention body semantics, required fields, auth expectations, or anything about the response.

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 short, front-loads the intent, and then gives useful forest/placement guidance in one follow-up sentence. A minor clarity issue with 'include values' is acceptable given overall brevity.

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 output schema covers return shape and the core path/query split is stated, but the role of body is unexplained and there is no explicit distinction from similar assignment/learner tools. It is enough to start with but requires the client or schema inspection to confirm full call shape.

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 meaningfully maps 'route IDs' to path_params and filtering/pagination/sorting/include values to query, which adds real info. However, it never explains what 'body' is for, and 'include values' is vague, leaving a gap in the 3-parameter contract.

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 learner activity for an assignment') and gives the exact GET endpoint. It does not explicitly differentiate from siblings like list_assignment_learners or get_assignment, but the resource framing is clear.

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 sibling tools such as get_assignment or list_assignment_learners. The only direction is where to place path and query values, which is parameter placement rather than use-case guidance.

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

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

With no annotations, the description carries the full burden. It discloses the HTTP verb (`GET`) and endpoint, which implies read-only behavior and no destructive side effects. However, it does not mention auth requirements, error behavior, or how missing departments are handled; the output schema does cover the response shape.

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, both substantive: the first states purpose, the second states the request construction details. It is front-loaded and contains no filler or irrelevant content.

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

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

For a simple GET-by-ID operation with an output schema present, the description gives enough to invoke the tool correctly: the endpoint, the path parameter location, and the query parameter categories. The only notable gap is the unexplained `body` parameter, but for a GET this is unlikely to block correct usage.

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 schema properties are generic `additionalProperties` objects, so the description must compensate. It usefully maps `path_params` to route IDs and `query` to filtering, pagination, sorting, and include values, but it does not name the exact expected query keys, clarify whether `body` should be omitted, or state which parameters are required.

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

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

The description opens with a specific verb and resource ('Get department details') and then pins the exact endpoint (`GET /departments/{departmentId}`). This makes it immediately distinguishable from the sibling `list_departments` and reinforces that it retrieves a single department.

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 operability guidance: route IDs belong in `path_params` while filtering, pagination, sorting, and include values belong in `query`. It does not explicitly name `list_departments` as the alternative for enumeration, but the single-resource endpoint and 'Get department details' make the intended context clear.

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. It discloses the HTTP method and parameter placement, but doesn't mention read-only nature (obvious from GET), error behavior, or pagination defaults. It adds a hint about query usage but is otherwise 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?

Two sentences, front-loaded with purpose and endpoint, then parameter placement. No redundant words or repetition of schema (which is empty).

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 output schema exists, so return format is covered. However, the description doesn't mention required parameters, auth, or failure cases. For a simple GET, it's adequate but could state that path_params must include an episodeId.

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 explains the role of path_params (route IDs) and query (filtering, pagination, sorting, include), but doesn't enumerate specific fields or formats. This is basic guidance but not exhaustive.

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 'Get training episode details' – a specific verb and resource – and specifies the exact endpoint `GET /episodes/{episodeId}`, distinguishing it from list_episodes. The agent can immediately understand this fetches a single episode by ID.

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 explicit guidance on where to place inputs: route IDs in path_params and filtering/pagination/sorting/include in query. This is actionable, though it doesn't explicitly state when to choose this over list_episodes; the distinction is implied by 'details' and the endpoint.

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 must carry behavioral disclosure. It reveals the HTTP method and route, implying a read-only operation, but does not mention authentication requirements, error handling, rate limits, or what happens if the group is not found. The output schema exists but the description itself adds little beyond the API call.

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 compact two-sentence definition that leads with the purpose and then gives parameter placement. There is no redundant or filler content, and it is appropriately front-loaded.

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 GET endpoint with an output schema, the description covers the essential call and parameter placement. However, it omits important context such as whether the body should be used, what specific query parameters are supported, and how errors are surfaced. These gaps are moderate given the tool's simplicity and the presence of an output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It tells the agent that path_params should hold route IDs and query should hold filtering/pagination/sorting/include values, which is a start. However, it doesn't specify exact key names or formats, leaving the generic additionalProperties schema ambiguous. This is insufficient for a tool with a fully generic schema.

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

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

The description clearly states 'Get learner group details' with a specific verb and resource. It also names the underlying HTTP call, making it unambiguous. While it doesn't explicitly contrast with list_groups, the singular 'group' vs. plural 'groups' is implicit, and the sibling list_groups serves as an obvious 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 placement guidance ('Put route IDs in path_params...') but gives no explicit context for when to choose this tool over siblings. It doesn't state prerequisites like requiring a groupId, nor does it mention when NOT to use it (e.g., when listing groups). The parameter-placement hint is useful but the when-to-use guidance is absent.

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

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

With no annotations provided, the description carries the full burden. It discloses the HTTP method (GET), which implies a read-only, non-destructive operation, but it does not describe error behavior, authentication requirements, or any side effects (none expected). It also doesn't mention pagination or response format, though an output schema exists. The description adds minimal behavioral context beyond the HTTP verb, so a mid-range score is appropriate.

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 with zero wasted words. The primary purpose is stated first, followed by a concise parameter-placement rule. Every clause adds information, and the description is short enough to be absorbed quickly by an agent.

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 GET endpoint with an output schema, the description covers the essential usage: what it does, the HTTP method, and where to put parameters. The only gap is that it doesn't explicitly state that learnerId is required (though the endpoint implies it) or describe what happens if it's missing. Given the schema marks all parameters as optional, an agent might call without path_params and receive an error. This minor omission prevents a perfect score.

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 has zero description coverage (no parameter descriptions), so the description must compensate. It does so by clarifying the roles of the three parameter objects: path_params for route identifiers (like learnerId), and query for filtering, pagination, sorting, and include values. Body is not mentioned, which is fine for a GET. This mapping is valuable and helps the agent construct a valid request, even though it doesn't enumerate specific query keys.

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 ('Get'), a clear resource ('learner details'), and explicitly names the REST endpoint with the {learnerId} placeholder. This unambiguously distinguishes it from list_learners (plural) and other account-scoped tools. The intent is immediately obvious 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 for when to use the tool: retrieve a single learner by ID. It provides guidance on how to structure the call (path_params for route IDs, query for filtering/pagination/sorting/include). However, it does not explicitly mention alternatives like list_learners or state when not to use it, though the singular 'learner details' and the endpoint make the use case fairly evident.

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 present, so the description carries the behavioral burden. It discloses the HTTP method (GET) and parameter routing, which implies a read-only call, but it does not describe response characteristics beyond the output schema, nor edge concerns like pagination behavior, error conditions, or authorization needs.

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 with no filler. The main purpose is front-loaded, and the second sentence efficiently communicates parameter placement. The phrasing 'or include values in query' is slightly awkward but still compact.

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 schema is entirely generic (additionalProperties), the description is the only source of parameter semantics and only partially covers them. It addresses path_params and query but leaves the body ambiguous and query specifics underspecified. The existence of an output schema reduces the need to document return values, and this is a simple GET, so the gaps are moderate rather than severe.

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 clarify that route IDs belong in `path_params` and filtering/pagination/sorting/other values go in `query`, which is helpful. However, the `body` parameter is never mentioned, and 'include values in query' is vague about exact accepted query keys.

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 'Get phishing campaign details' – a clear verb and resource – and reinforces it with the exact endpoint `GET /phishing-campaigns/{phishingCampaignId}`. This distinguishes it from sibling `list_phishing_campaigns` by signaling singular retrieval vs. listing.

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

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

The description gives some situational guidance about where to place IDs (path_params) versus query values, but it never explicitly says when to choose this tool over alternatives like `list_phishing_campaigns` or `get_phishing_campaign_scenario`. Usage context is implied by the word 'get' rather than stated.

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?

Calls out that it invokes GET, which strongly implies a read-only non-mutating operation, and mentions query-level filtering/pagination/sorting behavior. With no annotations, however, the full burden falls on the description, so the lack of any auth, error, or side-effect context leaves a residual gap. It does not contradict any annotation.

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 exist with the core purpose and routing rule placed immediately. The phrase 'filtering, pagination, sorting, or include values in query' is slightly awkward, but the description is compact and does not repeat schema fields. It earns its place without 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 single-resource GET with an output schema already available, the description covers the main call shape and where to place parameters. It does not, however, list exact query options, declare the required ID parameter clearly, or differentiate from related sibling retrievers, so it is only minimally sufficient. Body and auth behavior are also left unaddressed.

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

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

The input schema is generic open objects with 0% description coverage, so the description is the only place telling the agent where parameters belong. It usefully separates route IDs into path_params and filter/pagination/sorting/include values into query, but it does not name exact parameter keys or address the body parameter. This is partial compensation for an otherwise empty schema.

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

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

The description clearly states the tool retrieves a single campaign-scenario's details and names the exact GET endpoint. It is easy to tell apart from list_phishing_campaign_scenarios because 'get' implies retrieval of one item. It does not explicitly separate itself from get_phishing_campaign_scenario_campaign or get_phishing_campaign_scenario_scenario, but those sibling names indicate different related resources.

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 routing mechanics (put route IDs in path_params, put filtering/pagination/sorting in query), but it gives no guidance on when to choose this tool over sibling tools such as list_phishing_campaign_scenarios or get_phishing_campaign_scenario_campaign. No exclusions, prerequisites, or 'use this instead of...' statements are present.

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 behavioral burden. The verb 'Get' and the GET endpoint imply a read-only operation, and parameter placement is described. However, it doesn't disclose any additional behaviors like rate limits, auth requirements, or response shape, though an output schema exists to cover return format.

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 with no filler. The purpose is front-loaded, followed by the endpoint and parameter placement guidance. Every sentence 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 a simple GET with three optional parameters, and an output schema is present. The description covers the endpoint, parameter placement, and the relationship being fetched. It doesn't explicitly contrast with get_phishing_campaign_scenario_scenario, but the name and description make the distinction clear. Minor gaps like auth or error handling are not critical for a basic read operation.

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 does provide guidance: route IDs go in path_params, and filtering/pagination/sorting/include values go in query. This adds meaning beyond the generic object schemas, but it doesn't specify which route IDs (though the endpoint implies phishingCampaignScenarioId) or list concrete query parameters. Body is not mentioned, leaving some ambiguity.

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

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

The description clearly states the tool fetches the campaign associated with a campaign-scenario, naming the exact resource and relationship. It also provides the underlying endpoint, and the name distinguishes it from siblings like get_phishing_campaign_scenario_scenario, so an agent can tell them apart.

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 context is clear: use this when you need the campaign linked to a specific campaign-scenario. It gives explicit instructions on where to place route IDs (path_params) and query options (filtering, pagination, sorting, include values). However, it doesn't explicitly list when not to use it or compare to alternatives, though the naming implies the distinction.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions a GET call, implying a read-only operation, but does not state safety, data exposure, authentication requirements, or pagination limits. This is insufficient for full transparency.

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 short but structurally awkward: 'Put route IDs in path_params and filtering, pagination, sorting, or include values in query' is grammatically ambiguous and could mislead an agent. It is concise but sacrifices clarity.

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 empty schema coverage and three generic parameters, the description is incomplete. It does not specify that a path parameter is likely required despite the schema marking all parameters optional, nor does it list the supported query fields. An agent would need external API knowledge to invoke this correctly.

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

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

Schema coverage is 0%, so the description must compensate. It offers some guidance: route IDs go in path_params and filtering/pagination/sorting/include values in query. However, it is vague, omits body semantics, and does not name expected keys such as phishingCampaignScenarioId or query parameter names.

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

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

The description clearly states the tool gets the phishing scenario associated with a campaign-scenario, which is specific and easily distinguishable from siblings like get_phishing_campaign_scenario or get_phishing_campaign_scenario_campaign. It also shows the explicit endpoint path, removing 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?

No guidance is provided about when to prefer this tool over the closely related get_phishing_campaign_scenario or get_phishing_scenario. The second sentence only explains where to place parameters, not which tool should be used in which 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 behavioral burden. It does disclose that this is a GET request (read-only) and that filtering, pagination, sorting, and includes are supported via query parameters. However, it omits auth requirements, error cases, and response-handling details.

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

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

Two sentences, front-loaded with the core purpose, then the API pattern and parameter placement. Every sentence earns its place 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?

The output schema covers return values, so that gap is acceptable. But the description does not clarify that a single scenario is fetched by ID, does not state that the ID is required, and gives no usage context relative to sibling tools. It is minimally viable for a simple GET, but not more.

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

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

Schema coverage is 0% and all three parameters are free-form objects, so the description must compensate. It adds useful placement guidance ('route IDs in path_params', 'filtering, pagination, sorting... in query'), but it never names specific parameter keys or explains the body parameter, leaving significant ambiguity.

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 ('Get phishing scenario details') and specifies the exact endpoint `GET /phishing-scenarios/{phishingScenarioId}`. This makes the tool's function unambiguous, though it does not explicitly contrast itself with sibling list/get 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?

No guidance is given on when to use this tool instead of alternatives like list_phishing_scenarios or get_phishing_campaign_scenario. The only usage hint is where to place parameters, which is more parameter semantics than tool-selection guidance.

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

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

No annotations are present, so the description carries full disclosure burden. It reveals the HTTP verb and parameter placement, implying a read-only list call, but does not describe pagination defaults, response shape, rate limits, authorization requirements, or anything about the optional body parameter. The burden is not met.

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 carry the purpose, the endpoint, and the parameter placement rules. Front-loaded and free of 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?

Output schema exists, so return format is covered. Endpoint and param-placement conventions give a workable baseline, but the description leaves the body parameter unexplained and does not disambiguate the heavily overlapping sibling list_admin_users. Adequate but with clear gaps.

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% (all three parameters are generic additionalProperties objects), so the schema provides no meaning. The description adds partial compensation by mapping path_params to route IDs and query to filtering/pagination/sorting/include values, but it never lists which route IDs or which filter/sort keys are supported.

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

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

States a specific verb and resource: 'List account administrators' plus the exact endpoint GET /accounts/{accountId}/users. However, it does not differentiate itself from the sibling list_admin_users, so an agent must guess which tool covers account-scoped admins versus a global 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?

Provides placement guidance (route IDs in path_params; filtering, pagination, sorting, include values in query), which helps invocation. But it gives no when-to-use or when-not-to-use context relative to alternatives such as list_admin_users, and no mention of required accountId.

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 disclosure burden. It reveals the HTTP method (GET) and the readable/read-only nature of listing assignments, which are helpful. However, it does not mention authentication, rate limits, potential absence of data, or behavior when required path parameters are missing, so the transparency is only partial.

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

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

The description is three short sentences, purpose-leading, and efficient. It includes the endpoint and the essential placement instruction without excessive detail. The phrase 'or include values in query' is slightly vague but does not add bloat.

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

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

With an output schema present, return values are covered. Still, the description fails to specify that an account ID is effectively required in path_params for the call to succeed, and it offers no cross-reference to alternative tools. It is adequate for a straightforward GET list but incomplete for an agent to handle all necessary scenarios.

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

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

Since the input schema is entirely generic (all additionalProperties, 0% coverage), the description compensates by explaining that route IDs belong in path_params and filtering/pagination/sorting belong in query. It omits the body parameter's role, but it provides enough meaning to make sense of the generic object containers.

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 verb 'List' and the resource 'assignments' with an account scope, and further specifies the GET endpoint. It distinguishes the resource (account assignments) from other siblings, though it does not explicitly name list_assignments as the general 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 phrase 'for an account' implies this is for account-scoped assignments, which loosely suggests when to use it, but there is no explicit when-not or alternative tool reference. The bulk of the instruction is about parameter placement (path_params vs query), not when to choose this over 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 behavioral burden; it does disclose the HTTP method GET and 'List' semantics, implying a non-mutating read operation. However, it does not explicitly confirm no side effects, mention authorization, or describe pagination behavior, leaving some gaps the annotation usually fills.

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

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

The description is compact and front-loaded, with the core purpose in the first sentence and invocation details in the second. Every sentence contributes, though a sentence about when not to use it would improve it without adding much length.

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 invocation pattern and the tool's basic purpose, and an output schema is present. It lacks comparison with similar sibling tools, explicit guidance on the body parameter, and details on the accountId route parameter, making it adequate but not fully complete for an API-surface tool with no annotation support.

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 usefully assigns path_params to route IDs and query to filtering/pagination/sorting/include, but it does not explain the body parameter (only that body defaults to null) or the exact keys/expected values. The guidance is helpful but incomplete for all three schema properties.

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: 'List departments in an account' and explicitly names the endpoint. It clearly indicates account-scoped departments via 'in an account' and the accountId path, but does not explicitly distinguish itself from the sibling list_departments tool.

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

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

The description gives routing instructions ('Put route IDs in path_params and filtering, pagination, sorting, or include values in query'), but provides no guidance on when to choose this tool over list_departments or other sibling list tools. It lacks explicit alternatives, exclusions, or usage contexts.

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 reveals that the operation is a GET (implying read-only) and specifies parameter placement, which is useful. Yet it omits details like response structure (though output schema exists), potential pagination limits, sorting syntax, or whether the operation is safe/requires specific permissions. It adds some context beyond what would be inferable from the schema, but not enough for a fully transparent call.

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 wasted words. The core purpose is front-loaded, followed immediately by the endpoint and parameter routing guidance. Every sentence earns its place, and the structure is easy to scan.

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

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

For a list tool with an output schema and no required parameters, the description is reasonably complete: it states the endpoint, parameter placement, and the action. However, it does not specify that an accountId is mandatory (even though implied by the path), nor does it differentiate from `list_groups` or mention authentication/permissions. Given the sibling context and the need to route an agent correctly, the description leaves some gaps around when and with what constraints to call it.

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

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

The input schema is entirely open objects with `additionalProperties: true` and 0% coverage, so parameter meaning is undefined. The description compensates by explaining that path_params hold route IDs (implicitly the accountId) and query holds filtering/pagination/sorting options. This adds real semantic value beyond the schema, though it does not clarify the `body` parameter or the exact format of query values.

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 'List learner groups in an account' — a specific verb-resource pair — and reinforces it with the exact REST endpoint `GET /accounts/{accountId}/groups`. It distinguishes itself from the sibling `list_groups` by adding the 'in an account' scope, so an agent can tell which tool to use without opening 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 concrete placement instructions ('Put route IDs in path_params and filtering, pagination, sorting, or include values in query'), which is helpful for parameter usage. However, it does not explicitly state when to use this tool versus alternatives like `list_groups` (e.g., 'use this when you have an accountId, otherwise use list_groups'), nor does it mention any prerequisites or exclusions. The guidance is about how, not when.

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 explicitly identifies this as a read-only GET operation and explains where filtering, pagination, sorting, and include values go. It does not mention auth, rate limits, or pagination defaults, but the output schema covers return shape, so the gaps are not severe.

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 carry the full definition: the first states the purpose, the second gives the HTTP call and parameter routing. There is no filler or repetition of schema fields.

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 generic list wrapper, the description is largely complete: the endpoint identifies the required route ID, the parameter placement guidance is clear, and the output schema handles return value documentation. It could be improved by naming the actual query parameters and explicitly distinguishing it from `list_learners`, but those are minor given the generic schema.

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

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

Schema description coverage is 0%, and the schema uses generic `additionalProperties` objects. The description partially compensates by telling the agent that `path_params` holds route IDs and `query` holds filtering, pagination, sorting, and include values, but it does not enumerate the exact parameter names or formats, leaving significant inference required.

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

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

The description states a specific verb and resource: 'List learners in an account' and backs it with the exact endpoint `GET /accounts/{accountId}/learners`. This clearly distinguishes it from siblings like `list_learners` and `list_assignment_learners` by showing the account-level 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 account-scoped wording and endpoint give clear context for when to use this tool, and the instruction to put route IDs in `path_params` clarifies the expected invocation shape. It does not explicitly name alternatives or exclusion cases, but the context is strong enough for an agent to route correctly.

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 discloses that this is a GET request and explains parameter placement, which implies a safe read operation. It does not mention pagination defaults, response behavior, or any rate-limit/auth considerations, so transparency 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. It front-loads the purpose, then the endpoint, then the parameter placement, making it easy for an agent to parse and act on.

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 endpoint and the main parameter groups, and an output schema exists to document the response. However, it does not name the required path parameter (`accountId`) explicitly, nor list any valid query filter/sort/include keys, and the `body` parameter is unmentioned. It is workable but not fully complete for a generic schema.

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

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

Schema description coverage is 0%, so the description is the only source of parameter meaning. It usefully maps route IDs to `path_params` and filtering, pagination, sorting, and include values to `query`, which compensates for the generic schema. The `body` parameter is left unaddressed, but for a GET operation that is a minor omission.

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 operation: listing phishing campaigns for an account, and anchors it to the exact GET endpoint `/accounts/{accountId}/phishing-campaigns`. This differentiates it from the sibling `list_phishing_campaigns`, which is not account-scoped.

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 practical context: it is account-scoped and specifies where parameters belong. However, it does not explicitly state when to prefer this over `list_phishing_campaigns` or other list variants, so the usage guidance is implied rather than fully explicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only or mutating, what authentication or permissions are required, or whether results are paginated. It only indicates how to structure the request (route IDs in path_params, etc.) but no side effects or limitations. This is a significant gap for a listing operation.

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

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

The description is concise and front-loaded: the first sentence states the purpose, the second provides the HTTP endpoint, and the third gives usage routing. Every sentence adds value, with no filler or redundancy. It is appropriately structured for quick agent scanning.

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 a simple listing operation with an output schema that might cover return structure, and the description covers basic usage. However, it lacks behavioral context like pagination specifics, authentication, or error handling, which are important for an HTTP-based tool. The absence of annotations increases the need for such details, making the description only minimally 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?

Schema description coverage is 0%, and the schema has three parameters (body, query, path_params) with no property descriptions. The description attempts to compensate by explaining where to put route IDs (path_params) and filtering/pagination/sorting/include (query), which is helpful. However, it does not explain the 'body' parameter at all, leaving a third of the parameters undocumented. The partial guidance is insufficient to fully compensate for the lack of schema docs.

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 phishing scenarios for an account.' It names the specific resource and the HTTP endpoint, and it differentiates from the sibling tools that list scenarios globally (list_phishing_scenarios) or for campaigns (list_phishing_campaign_scenarios), making the purpose precise and non-confusable.

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 guidance on when to use this tool by specifying the account scope, and it implicitly distinguishes from siblings that list scenarios for other scopes. However, it does not explicitly mention when NOT to use it or point to alternatives, so it lacks explicit exclusions. The context is clear enough for an agent to infer usage.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the HTTP method (GET), implying a read-only operation, and explains where parameters go (path_params vs query). However, it does not disclose pagination behavior, response format, authentication requirements beyond 'authenticated administrator', or any side effects. The coverage is partial but not contradictory.

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 zero waste. The purpose is front-loaded in the first sentence, and the parameter guidance is concise and actionable. Every sentence earns its place, and the structure is easy to parse.

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 (a list operation) and the presence of an output schema (so return values need not be explained), the description covers the core purpose and parameter organization. However, it leaves the body parameter entirely unaddressed and does not mention any limitations or prerequisites beyond the admin audience. An agent would need to infer some details from the sibling set or the API documentation.

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 is generic (all params are open objects), and schema description coverage is 0%, so the description must compensate. It does clarify that path_params holds route IDs and query holds filtering, pagination, sorting, or include values. However, it completely omits the body parameter, leaving a third of the schema unexplained. The guidance adds value but is incomplete.

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') and resource ('accounts'), and clarifies scope ('available to the authenticated administrator'). It also names the HTTP endpoint, which distinguishes it from sibling tools like list_account_assignments or list_learners. The purpose is unambiguous and clearly tied to the tool's name.

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 some context ('available to the authenticated administrator') and explains parameter placement, but it does not explicitly state when to use this tool over its many siblings, nor does it mention any alternatives or exclusions. There is no guidance on when not to use it or how it differs from other list_account_* 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, the description must carry the full burden of behavioral disclosure. It only states that it lists reports and calls a GET endpoint, implying read-only behavior, but does not mention authentication requirements, pagination behavior, or what the response contains beyond what the output schema might imply.

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 no filler. It front-loads the primary purpose and then gives parameter placement hints. It is concise but could be better structured to separate intent from usage.

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 generic parameters and no annotations, the description is insufficient. It does not explain what constitutes an 'account summary report', how to distinguish this from the account-scoped sibling, or any prerequisite context. An agent would struggle to correctly invoke it without additional domain knowledge.

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 zero specific property definitions (all generic objects with additionalProperties), so the description's guidance on where to place route IDs and query values adds some meaning. However, it is vague—'route IDs' is ambiguous—and does not enumerate valid query parameters or value formats.

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 verb and resource: 'List account summary reports' and identifies the API endpoint. However, it does not explicitly differentiate from the sibling tool 'list_account_summary_reports_for_account', leaving an agent to infer the distinction based on names alone.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions parameter placement ('Put route IDs in path_params...') but does not explain the appropriate context for selecting this list operation over get_account_summary_report or the account-scoped sibling.

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 must carry behavioral disclosure. It does reveal the HTTP method and how parameters map to the request, implying a read-only operation, but it does not cover authentication, pagination, or anything else an agent should expect.

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

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

The description is compact and front-loaded: purpose first, then endpoint and param placement. It has no filler or repetitive content.

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

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

For a list tool with an output schema, it is a complete enough resource for the most common call. But the body parameter is omitted and the sibling overlap is unresolved, so it is not fully contextually 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 needs to compensate. It explains that path_params takes route IDs and query holds filtering/pagination/sorting/includes, but it never mentions the 'body' parameter, leaving its purpose ambiguous. Partial compensation, missing an entire input.

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' with a clear resource ('summary reports for an account') and gives the exact GET endpoint. It does not explicitly name sibling tools like list_account_summary_reports, but the 'for an account' qualifier and path template convey the intended 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?

There is no when-to-use or concourse between this tool and similarly named siblings such as list_account_summary_reports or get_account_summary_report. The description only explains how to place parameters, leaving the agent to infer which of the related tools to call.

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

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

No annotations are provided, so the description carries the full transparency burden. It states that the tool lists admin users by calling GET /users, but it does not mention authentication requirements, response shape, pagination behavior, rate limits, or whether the returned list is scoped globally or per account. Beyond the bare operation, behavioral context is largely missing.

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

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

The description is brief and front-loads the main purpose. The second sentence is slightly awkward ('Put route IDs in path_params and filtering, pagination, sorting, or include values in query') but still compact and mostly useful. No significant 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?

Given the tool has an output schema and a relatively straightforward list operation, the description does not need to explain return values in detail. It covers the endpoint and where to place path and query inputs. However, it does not address body usage, scoping, or how this compares with other list tools, so the overall context is only minimally 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 schema has generic object parameters only, so the description must compensate. It does add useful guidance by assigning path_ids to path_params and filtering/pagination/sorting/include values to query, which helps. However, it does not clarify what body is for or which query keys are expected, so the compensation is partial.

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 a specific verb and resource: 'List administrator users' and clarifies the underlying endpoint with 'Calls GET /users.' It is clearly a read/list operation, though it does not explicitly distinguish itself from the sibling list_account_admin_users or other list_account_* 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 parameter placement advice ('Put route IDs in path_params... filtering, pagination, sorting... in query') but no guidance about when to prefer this tool over alternatives, when not to use it, or any prerequisites. It does not mention the similarly named list_account_admin_users sibling, which leaves selection ambiguous.

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 discloses the HTTP verb GET, which implies a read-only operation with no destructive effects, and hints that pagination/filtering/sorting are supported via query parameters. However, it does not cover side effects, authentication or permission requirements, or how pagination behaves, and it provides no meaningful context beyond what "List" and "GET" already imply.

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 wasted words. The action and exact endpoint are stated up front, followed immediately by a terse but complete parameter-placement instruction. Every sentence earns its place and the agent can scan it fast.

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 that an output schema exists, the description need not explain return values, and the core calling contract is covered: endpoint, route ID placement, and query usage. The main remaining gap is the unexplained `body` parameter; combined with the absence of sibling differentiation, a bit more context would help. Overall, however, an agent has what it needs to invoke the tool correctly in the common case.

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 free-text description must compensate for three loosely-typed parameters. It partially does: it maps `path_params` to route IDs and `query` to filtering, pagination, sorting, and include values, which adds real meaning to the open schemas. The `body` parameter is never mentioned at all, leaving one of three parameters undocumented in both schema and description.

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 — "List assignment enrollment conditions" — and pinpoints the exact endpoint `GET /assignments/{assignmentId}/enrollment-conditions`, leaving no ambiguity about what is returned. It is readily distinguishable from the similar sibling `list_assignment_enrollment_extras` because the resource differs (conditions vs. extras), though it does not call out that sibling by name. This is clear and precise, but falls short of the top score because the description never explicitly differentiates itself from related 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 routing guidance — put route IDs in path_params and filtering/pagination/sorting/include values in query — which tells the agent how to fill the parameters. However, it never states when to prefer this tool over alternatives like `list_assignment_enrollment_extras` or when NOT to use it. Usage context is implied for a straightforward read/list operation, but explicit when/when-not guidance, as well as prerequisites such as needing the assignmentId, is absent.

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 behavioral burden. It communicates a read-only operation through 'List' and the explicit `GET` method, and it discloses how parameters are routed. It does not describe pagination defaults, result shape, or side effects, but none are expected for a simple list endpoint.

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

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

The description is compact and front-loaded with the core action and endpoint, followed by concise parameter placement guidance. The second sentence is slightly awkward ('include values in query') but earns its place because the schema provides no parameter details.

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 are covered. The endpoint and parameter placement instructions are enough to attempt a basic call, but the description leaves exact query parameter naming and the purpose of the `body` field unclear. For a generic-schema list tool, this is adequate but not 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 schema is generic open-object slots with no property documentation. The description compensates by explaining that `path_params` holds route IDs and `query` holds filtering, pagination, sorting, and include values. This is helpful but still vague: exact parameter names and formats are not specified, and the `body` parameter is not addressed.

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 operation ('List assignment enrollment extras') and gives the exact endpoint path, which makes the resource unambiguous. It does not explicitly contrast with the similar sibling `list_assignment_enrollment_conditions`, but the resource name and endpoint differentiate it well 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?

The description provides actionable guidance on where to place parameters: route IDs in `path_params` and filtering/pagination/sorting/include values in `query`. However, it does not state when to choose this tool over alternatives such as `list_assignment_enrollment_conditions` or `list_assignment_learners`, so selection 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?

No annotations are provided, so the description must carry behavioral disclosure. It does identify this as a GET request and clarifies how path and query parameters are used, which is helpful. However, it does not mention auth requirements, rate limits, default page sizes, or any side-effect-related caveats. For a simple read-only list tool this 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?

Two short sentences with no filler. The main purpose is front-loaded, followed by a concise routing rule. Every sentence 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 list endpoint with an output schema available, the description adequately covers the operation and the key parameter routing. It could be more complete by explaining the body parameter or giving an example of query parameters, but the endpoint and parameter conventions are enough for an agent to invoke it successfully.

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% and all three parameters are generic objects with no field descriptions. The description compensates by explaining that route IDs go in path_params and that filtering, pagination, sorting, or include values go in query. It does not explain the body parameter, but it appears optional and the description still adds meaningful parameter routing guidance beyond the schema.

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

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

The description states a specific verb and resource: 'List learners assigned to an assignment.' It also gives the exact API endpoint, which clearly separates it from siblings like list_learners, list_account_learners, and get_assignment. The scope is unambiguous.

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

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

The description gives clear context—this tool is for listing learners for a particular assignment—and practical routing instructions ('Put route IDs in path_params and filtering, pagination, sorting, or include values in query'). It does not explicitly name alternatives or when not to use it, but the context is clear enough for an agent to select it correctly.

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

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

With no annotations, the description carries the behavioral disclosure burden. It provides meaningful transparency by specifying the HTTP method and query capabilities, signaling a read-only list operation with filtering, pagination, and sorting 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 short and front-loads the endpoint. The second sentence is slightly run-on but still communicates the parameter placement rules without unnecessary 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?

Given the tool's relatively simple purpose and the presence of an output schema, the description covers the essential call mechanics: endpoint, parameter placement, and supported query features. It omits guidance on the `body` parameter and alternative sibling tools, but these are minor gaps.

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

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

Schema coverage is 0%, but the description compensates by explaining that route IDs go in `path_params` and filtering/pagination/sorting values go in `query`. It never mentions the `body` parameter, leaving one of the three parameters unaddressed.

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

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

The description clearly states the tool lists assignments and identifies the exact endpoint `GET /assignments`, so an agent knows the verb and resource. However, it does not explicitly distinguish itself from sibling list tools like `list_account_assignments` or `get_assignment`.

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 concrete how-to guidance by explaining where route IDs and query values go, but it never says when to choose this tool over alternatives. Usage is only implied by the tool name and endpoint.

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, and it does at least disclose 'Calls GET /departments', which strongly implies a read-only, side-effect-free operation. However, it does not mention auth, authorization scope, pagination defaults, or anything about the response shape, so it only covers the most basic behavioral signal.

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

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

The description is short and front-loaded: purpose, HTTP method, and parameter placement are each stated in a compact sentence. The initial 'List departments' is somewhat redundant with the tool name, but the whole definition avoids fluff and stays efficient.

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?

Without annotations, the description gives just enough to attempt a call: an HTTP method and parameter destination. But it is incomplete because it does not clarify what scope of departments this returns, how it differs from list_account_departments, or which route IDs apply. The output schema covers response shape, but the deciding contextual information about scope and alternatives is absent.

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% and all parameters are unconstrained generic objects, so any added meaning is valuable. The description tells the agent to put route IDs in path_params and filtering/pagination/sorting/include values in query_params, which is meaningful compensation for an empty schema. It does not explain the unused body param, a minor 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 clearly states a specific verb and resource, 'List departments', and even names the exact endpoint via 'GET /departments'. It is not self-contradictory, but it fails to differentiate from the sibling list_account_departments, so an agent cannot tell whether this returns global or account-specific departments.

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 about when to use list_departments instead of alternatives such as list_account_departments or get_department. The only usage-related text is mechanical ('Put route IDs in path_params...'), which does not help select between 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 present, the description carries the behavioral disclosure burden. It explicitly says the call is `GET /episodes`, signaling a non-mutating read, and notes that filtering, pagination, sorting, and include values belong in the query. It does not discuss auth, rate limits, or side effects, but for an idempotent read operation this is reasonable.

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

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

Two short sentences, with the purpose and endpoint front-loaded and the parameter routing appended in the second sentence. No filler or repetition.

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 gives the endpoint, method, and parameter-placement rules, and an output schema is present to describe the return shape. It is complete enough for a simple list call, though it leaves `body` unexplained and gives no examples of accepted filter/sort values.

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%, and the schema only offers generic `body`, `query`, and `path_params` objects. The description compensates by assigning route IDs to `path_params` and filtering/pagination/sorting/include values to `query`, which is essential. It does not address the `body` parameter or give concrete query-key names, so coverage remains partial.

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 the action ('List') and resource ('training episodes') explicitly, and pins the exact endpoint (`GET /episodes`). This distinguishes it from the sibling `get_episode` (collection vs single resource) and from list tools for other resources. No ambiguity about what the tool does.

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 no when-to-use guidance or alternatives—`get_episode` is never mentioned for single-item retrieval. The intended use is only implied by the verb 'List' and the endpoint. The parameter-placement note is about how to call, not about when to choose this tool over 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 provided, the description must carry the full burden. It discloses the HTTP method and parameter placement, but fails to mention behavior such as pagination defaults, read-only nature, or any side effects. This is minimal disclosure for a non-trivial API call.

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, front-loaded with the core purpose and endpoint. Every word earns its place, with 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?

Given the output schema covers return values, the key missing piece is distinguishing this from `list_account_groups`. The description also omits common query parameter details (like limit/offset) that would be needed for correct invocation. It is technically usable but leaves gaps for an agent to risk errors.

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 explains that route IDs go in path_params and filtering, pagination, sorting, or include values go in query. This adds meaningful context to otherwise generic fields, though it does not enumerate possible query parameters or 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 clearly states 'List learner groups' and specifies the endpoint `GET /groups`, giving a clear verb and resource. However, it does not differentiate from the sibling `list_account_groups`, which could be confused, so it lacks explicit 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?

The description provides guidance on where to place parameters (path_params vs query), but offers no guidance on when to use this tool versus other list tools, nor any exclusions or alternatives. It is purely operational, not decision-oriented.

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 explicitly reveals the HTTP method (GET /learners), implying a read-only operationaine, and clarifies parameter placement. However, it does not disclose scoping, authentication needs, pagination behavior, or result characteristics beyond what the output schema provides.

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

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

The description is brief and front-loaded with the core purpose. The second sentence adds useful routing and parameter-placement details without wasted words.

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

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

Given the generic schema and many sibling list tools, the description is serviceable but incomplete. It covers the HTTP route and rough parameter placement, but it does not clarify the learner scope or mention whether body values are ever used, which could lead to incorrect 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 schema properties are generic open objects, so the description must compensate. It adds meaning by mapping route IDs to path_params and filtering/pagination/sorting/include values to query, but it does not list specific accepted query keys or explain the body parameter.

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

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

The description identifies a specific verb and resource ('List learners') and gives the exact HTTP route. However, it does not distinguish this from similar sibling tools like list_account_learners or list_assignment_learners, leaving some ambiguity about 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 explains where to place route IDs and query parameters, but it provides no guidance on when to choose this tool over sibling alternatives. It does not state whether this lists all learners globally or within a particular account/assignment 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 only states the API call and parameter placement, without mentioning whether the operation is read-only, authentication requirements, rate limits, or error behavior. The name 'list' implies non-destructive, but the description does not explicitly add any behavioral context beyond that.

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 fluff. It front-loads the action and resource, then provides a compact routing hint. Every word earns its place, making it easy to parse quickly.

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

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

An output schema exists, so return values need not be described. However, the description omits essential context like whether phishingCampaignId is required (likely yes, but not stated), potential error conditions, or how this tool fits among the many sibling tools. While it covers the basic how-to, an agent might struggle to use it correctly without knowing that the path parameter is mandatory. The presence of the output schema raises the baseline, but the missing required-parameter note and lack of alternative guidance leave gaps.

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 partially does by explaining that path_params hold route IDs and query holds filtering/pagination/sorting/include values. This adds meaning to the otherwise opaque schema, but it does not enumerate specific keys or formats, leaving the agent to infer the exact parameter structure. It adds some value but is not comprehensive.

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 phishing attempts) and the resource (a campaign), and distinguishes from siblings like list_phishing_campaigns (lists campaigns) and list_phishing_campaign_scenario_attempts (attempts for a scenario) by specifying 'for a campaign'. The API endpoint is provided, making the purpose unambiguous.

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

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

The description gives practical usage instructions: 'Put route IDs in path_params and filtering, pagination, sorting, or include values in query.' This tells the agent where to place different kinds of input. However, it does not explicitly contrast with alternative tools or state when to prefer this one over, say, list_phishing_campaign_scenario_attempts. The context is implied but not explicit.

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

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

No annotations are provided, so the description carries the full burden. It discloses the HTTP method (GET) and parameter routing, but doesn't mention pagination behavior, response shape, authentication needs, or any side effects. For a list operation this is a moderate 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 sentences, front-loaded with the core action and endpoint, then routing guidance. No wasted words, though the routing guidance could be more specific.

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 an output schema, so return values are covered elsewhere. But with 0% schema coverage, no annotations, and generic schema properties, the description should explain what route IDs are expected, what query parameters are supported, and how this relates to sibling tools. It doesn't.

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 schema is generic (body/query/path_params with additionalProperties). The description adds some meaning by saying route IDs go in path_params and filtering/pagination/sorting/include values go in query, but it doesn't specify which route IDs, what filter keys exist, or what include values are valid. It partially compensates but leaves most semantics undefined.

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 ('List phishing campaigns') and names the exact HTTP endpoint. It distinguishes from siblings like get_phishing_campaign and list_phishing_campaign_attempts by the resource and list scope, though it doesn't explicitly name a sibling.

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 routing guidance: route IDs go in path_params and filtering/pagination/sorting/include values go in query. However, it doesn't state when to prefer this tool over alternatives like list_account_phishing_campaigns or get_phishing_campaign, nor any 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 present, behavior must come from the description. It does disclose that this calls a GET endpoint, so the operation is clearly read-only, and it implies there are no destructive side-effects. However, it does not mention permissions, authentication, rate-limit implications, or what happens when no attempts exist, so the transparency is only partial.

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

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

The text is short and front-loads the purpose, followed by a parameter-placement hint with no filler. The grammar of the sentence 'Put route IDs in path_params and filtering, pagination, sorting, or include values in query' is confusing, preventing a perfect score.

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 complete absence of useful schema constraints and annotations, the description bears much more weight and is not complete. It tells the agent little more than the existence of path and query bags, leaving body semantics unknown and the specific query keys undocumented. The output schema may describe the response, but request construction remains under-specified for a typical list endpoint.

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 provides only empty objects with additionalProperties, leaving 0% coverage. The description offers meaningful guidance by saying route IDs belong in path_params and that filtering, pagination, sorting, or 'include' values go into query. This helps, but it never mentions the body parameter nor lists the actual query key names, so an agent with no other context will struggle to construct specific valid requests.

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

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

The description clearly states the action and resource: 'List attempts for a campaign-scenario' and reinforces it with the exact endpoint, which distinguishes it from adjacent siblings such as list_phishing_campaign_attempts and list_phishing_campaign_scenarios. It could be improved by an explicit contrast to list_phishing_campaign_attempts, but the current wording is specific 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?

The description implies when to use the tool simply by stating that it lists attempts for a campaign-scenario, but it never says when not to use it, nor does it route to any alternative. There is no explicit handling of the choice between this and the closely related attempt or scenario listers, leaving the agent to infer based on the 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?

No annotations are provided, so the description must carry behavioral disclosure. It indicates a GET call (read-only) and mentions filtering, pagination, sorting, and include values, which is useful. However, it does not disclose auth requirements, rate limits, or what the response array contains beyond the existence of an output schema. It adds moderate value but is not thorough for a tool with zero 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 two sentences, front-loaded with the primary purpose and endpoint. It is efficient with no fluff. It could be slightly more structured (e.g., bullet-like clarity), but it is appropriately concise and readable.

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 generic schema and presence of an output schema, the description covers the core intent and parameter placement. However, it lacks explicit mention of required fields (like phishingCampaignId) and does not clarify whether the body parameter is ever used (it is a GET call). While the endpoint hints at requirements, the description leaves some gaps for an agent to infer.

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 explains that path_params should contain route IDs and query should hold filtering/pagination/sorting/include values, which is helpful. Yet it does not specify the exact key names (e.g., phishingCampaignId) or provide any structure for the generic objects. This leaves significant ambiguity for an agent to construct valid calls.

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 scenarios attached to a phishing campaign') and specifies the resource (scenarios for a campaign). It distinguishes from sibling tools like list_phishing_campaigns (lists campaigns) and list_phishing_scenarios (all scenarios), making the purpose unambiguous.

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

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

The description gives practical guidance on where to place parameters ('route IDs in path_params, filtering... in query'), which helps invocation. However, it does not explicitly state when to use this tool versus alternatives (e.g., get_phishing_campaign_scenario for a single scenario) or provide exclusions. Usage context is implied by the name and endpoint rather than spelled out.

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 the HTTP method (GET) and the general parameter placement, but it does not disclose pagination behavior, default page size, rate limits, authentication requirements, or what the response contains. The output schema exists but the description adds little behavioral context beyond the endpoint.

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 and front-loads the core purpose. The second sentence adds practical routing guidance without excessive detail. It is concise and every sentence earns its place, though it could be slightly more structured with explicit parameter mapping.

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 moderate complexity (3 generic parameters, no annotations, output schema present), the description provides the essential endpoint and parameter placement but lacks details on valid path parameters, query options, and response behavior. It is adequate for a simple list operation but leaves gaps that an agent might need to resolve by inspecting the output schema or making trial calls.

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 three generic parameters (body, query, path_params). It does clarify that path_params holds route IDs and query holds filtering/pagination/sorting/include values, which is helpful, but it does not explain what specific route IDs are valid, what filters are supported, or what the body parameter is for. The schema itself is generic with additionalProperties, so the description only partially compensates.

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: 'List phishing scenarios' and explicitly names the HTTP endpoint `GET /phishing-scenarios`. It distinguishes itself from sibling tools like `list_account_phishing_scenarios` and `get_phishing_scenario` by focusing on the top-level collection, though it doesn't explicitly name those siblings.

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 some usage guidance by specifying where to put route IDs (path_params) and filtering/pagination/sorting/include values (query). However, it does not explain when to use this tool versus alternatives like `list_account_phishing_scenarios` or `get_phishing_scenario`, leaving the selection context implicit.

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 usefully discloses the HTTP POST method and how parameters are routed, making the mutation explicit. But it omits side effects, idempotency, authorization needs, or reversibility, so the behavioral picture is incomplete.

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 short sentences, each earning its place: purpose, endpoint, and parameter placement. It is front-loaded with the core action and contains 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 an unannotated mutation tool with generic input schema, the description gives a useful high-level invocation pattern but leaves the agent to infer concrete payload fields and prerequisites. The output schema covers return values, so that is not a gap, but side effects and exact body requirements remain unclear.

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 is fully generic with 0% schema coverage, so the description must compensate. It does by mapping each opaque bucket to a role: route IDs in path_params, filtering/pagination/sorting/include in query, and JSON:API payload in body. Exact parameter names are still absent, but the description adds substantial meaning beyond the schema.

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

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

The description names a specific action and resource: 'Mark a phishing attempt reported using a code or message ID,' and reinforces it with the exact endpoint. The sibling tools are dominated by list/get/delete operations, so this report action is clearly distinguishable.

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 a phishing attempt needs to be marked reported using a code or message ID. However, there is no explicit when-not-to-use guidance or mention of alternatives, such as first finding the attempt via list_phishing_campaign_attempts.

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 mentions the HTTP method and endpoint, but it does not explain side effects, required permissions, whether the update is partial or full, or what the response contains. For a mutating operation, this is insufficient transparency.

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 short sentences, each earning its place: one states the purpose, one handles routing parameters, and one specifies the body format. No redundant filler or rephrasing 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?

The description gives essential high-level instructions and an output schema exists, but it omits details like the exact path parameter name, required body fields, and query parameter semantics. An agent could call the endpoint correctly in many cases, but ambiguity remains around constructing a valid JSON:API payload.

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 parameters are generic object types. The description compensates meaningfully by assigning semantic roles: path_params holds route IDs, query holds filtering/pagination/sorting/include values, and body carries the JSON:API payload. It does not enumerate exact fields, but it converts opaque object slots into actionable guidance.

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 identifies the operation: updating an administrator user via `PATCH /users/{userId}`. This distinguishes it from sibling tools like `create_admin_user`, `get_admin_user`, and `delete_admin_user`, all of which are listed alongside it.

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 explaining where each kind of input should be placed: route IDs in path_params, filtering/pagination/sorting/include in query, and JSON:API payload in body. It does not explicitly name alternatives or state when not to use this tool, but the context is unambiguous enough for an agent to proceed correctly.

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