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

No annotations are provided, so the description must carry the burden of behavioral disclosure. It only says 'custom API request' without mentioning that this tool can issue GET, POST, PUT, PATCH, or DELETE calls, may mutate or delete data, requires authentication, or can have side effects. The phrase 'advanced operations' hints at risk but does not meaningfully disclose behavior.

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

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

The description is two short sentences with no filler. The core action is front-loaded and the usage hint is concise. Every word earns its place.

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

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

For a raw API execution tool with no output schema and no annotations, the description is under-specified. It does not clarify response format, error behavior, endpoint base URL conventions, authentication expectations, or the destructive potential of methods like DELETE. An agent would have too little context to safely invoke this tool compared to the specialized siblings.

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

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

Schema description coverage is 100%, so the input schema already documents method, endpoint, and optional data. The description adds no parameter-specific meaning beyond calling the request 'custom,' which is acceptable but not additive. This warrants the baseline score of 3.

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 action ('Execute a custom API request to Planview') and distinguishes it from the sibling tools by positioning it for advanced operations not covered elsewhere. It is slightly generic because it does not specify what kinds of requests or outcomes are involved, but it is sufficient for a generic gateway 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 says this tool is 'useful for advanced operations not covered by other tools,' which gives clear when-to-use context and implies that the specialized sibling tools should be preferred when applicable. It does not explicitly name alternatives or state hard exclusion criteria, so it falls just short of a 5.

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

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

With no annotations, the description carries the full burden and does disclose the core read-only behavior via 'Get information'. It does not mention response contents, authentication requirements, or failure modes, but for a simple no-parameter getter these omissions are less impactful.

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

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

A single sentence with no filler; the core action and target are front-loaded. Nothing extraneous is included.

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

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

For a simple current-user getter with no parameters and no output schema, the description is nearly complete for invoking the tool. It could add what fields are returned or clarify that the result is the authenticated caller's profile, but the current wording is enough to select and 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 tool has zero parameters, so the schema fully covers parameter semantics vacuously. The description does not need to explain parameters, and the baseline for zero-parameter tools applies.

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

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

The description uses a specific verb ('Get') and a specific resource ('information about the currently authenticated user'), making the tool's purpose immediately clear. It is naturally distinct from sibling tools focused on work items, projects, and requests, though it does not explicitly call out that 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 phrase 'currently authenticated user' implies the tool is used when the agent needs the identity or profile of the caller, but no explicit when-to-use or when-not-to-use guidance is provided. There are no sibling user-focused tools to contrast with, so the implied usage is reasonably 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 full burden. 'Get details' indicates a read operation and implies no destructive side effects, but it does not disclose error behavior, authorization requirements, or return format. This is acceptable for a simple read 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?

A single front-loaded sentence with no redundant words or filler. Every piece of information in the description is necessary.

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

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

For a one-parameter read-only lookup tool, the description gives enough to invoke it correctly. It could mention what kind of details are returned, but the low complexity and lack of an output schema make the current text 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?

Scheme coverage is 100% because the only parameter 'id' is documented as 'The project ID'. The description adds little beyond confirming the lookup is by ID, so it stays at the baseline for well-covered schemas.

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

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

The description uses a specific verb and resource ('Get details of a specific project') and explicitly scopes the call to a project by ID, distinguishing it from the sibling planview_get_projects. An agent can clearly tell this is the singular lookup 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 'by ID' qualifier provides clear context: use this when you have a project ID and need a single project record. It does not explicitly name alternatives or exclusion criteria, but the intended use is 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?

With no annotations, the description carries the full burden for behavioral disclosure. It communicates a basic read operation but does not mention pagination, result shape, default behavior, auth requirements, or whether filters are required for large datasets. This is a minimal disclosure for a list 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 one short, direct sentence with no filler or unnecessary clauses. It is front-loaded with the core operation and is as concise as possible at this level of detail.

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

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

The tool has one nested object parameter, no output schema, and no annotations, so the description must explain enough about expected behavior and return values. It does not clarify what filters are valid, what the returned list contains, or how it differs from sibling tools, leaving the agent without enough context to invoke it confidently.

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?

Although schema description coverage is reported as high, the only parameter's schema description is a tautology ('Optional filters to apply') and the tool description merely repeats that filters are optional. Neither source defines what filter keys, operators, or value types are supported, so an agent cannot understand how to populate the 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 clearly states the action ('Get a list') and the resource ('projects'), and the plural form helps distinguish it from the singular 'get_project' sibling. However, it does not explicitly address why a caller would choose this over related tools like get_work_items.

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 this tool versus alternatives. The description only hints that filters are optional, but does not say when filtering is needed, how to structure filters, or when to prefer a sibling tool.

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 convey safety and side effects. The verb 'Get' implies a read operation, but the description does not explicitly confirm it has no side effects, does not require authorization, or describe error behavior. It is adequate but 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?

One short sentence carrying precisely the essential information: the action, the object, and the selection key. No filler, no repetition of what the schema already says.

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-parameter getter tool, the description covers the core call: what it acts on, the identifying input, and the result (details). It does not document response structure or errors, but the lack of an output schema and the simplicity of the tool make the description 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 coverage is 100% and the single id parameter is already described as 'The work item ID'. The description merely repeats the 'by ID' concept without adding format, source, or behavioral expectations, so it adds no real value 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 uses a specific verb ('Get') and resource ('details of a specific work item'), and explicitly scopes by ID, making it clear this is a singular fetch operation. This distinguishes it from the plural sibling planview_get_work_items without requiring 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 implies the tool should be used when you have a specific ID and need its details, and the sibling names suggest alternatives like update or list. But it does not explicitly state when not to use it or contrast it with alternatives, leaving usage guidance mostly 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 present, so the description must carry behavioral information. 'Get a list' implies a read-only retrieval that returns multiple work items, and 'optional filters' implies result scoping. However, it does not disclose defaults when no filters are supplied, pagination, limits, or 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?

One short sentence that leads with the verb and object. It contains no filler and is appropriately sized for a simple endpoint with a single optional parameter.

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

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

For a tool with one optional parameter and no output schema, the description gives the essential call shape. But it does not state what happens when no filters are provided, how results are returned, or when to prefer the singular variant, leaving some information for the 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 100%, and the schema already documents the optional filters object with a concrete example. The description only repeats 'optional filters' and adds no new 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 states a specific operation—getting a list of work items—and the plural 'list' distinguishes it from the sibling tool planview_get_work_item. It also mentions optional filters as part of the operation.

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

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

No explicit guidance is given about when to use this tool versus planview_get_work_item or planview_update_work_item. The plural vs singular naming implies this is for bulk retrieval, but the description leaves that inference to the agent.

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 behavioral disclosure burden. It only restates the mutation ('Update a work item') and adds no context about side effects, idempotency, permissions, response behavior, or error cases.

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

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

The description is a single concise sentence and is easy to scan. The phrase 'with new data' is somewhat redundant since an update inherently involves new data, but it is not misleading or verbose.

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

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

For a simple two-parameter update tool, the schema covers the inputs adequately and the purpose is clear. However, with no annotations, no output schema, and no behavioral explanation, the description leaves the agent without expectations about return values or side effects.

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

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

Schema description coverage is 100%, and the schema already documents both parameters including an example for data. The description adds no additional meaning beyond what the schema provides, so the baseline of 3 applies.

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

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

The description states a specific verb, 'update', and a clear resource, 'work item'. It is distinguishable from the get_* siblings by the update verb, though it does not explicitly differentiate itself from planview_execute_request.

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 getting a work item or executing a generic request. No conditions, prerequisites, or exclusions are provided.

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