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

With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool both configures and validates credentials, and that it is a prerequisite for all other tools. However, it does not describe side effects such as overwriting existing credentials, error behavior on invalid input, or whether it is idempotent. This is a notable omission for a configuration tool, but the stated prerequisite behavior adds some value.

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

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

Two concise sentences, each carrying essential information. The purpose is stated first, and the prerequisite condition is added in the second sentence without redundancy. Every word earns its place, making it highly 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?

Given that an output schema exists, the return value is likely covered there. However, the description does not mention failure modes, whether the tool can be called multiple times, or any setup details beyond the prerequisite. For a configuration tool that gates all others, this is only moderately complete; it tells the agent when to call it but not what to expect on success or failure.

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 explain what the three parameters (client_id, client_secret, refresh_token) are and how they relate. The description only says 'Zoho OAuth credentials' without mapping these to the parameters or providing any additional detail. This is a critical gap that leaves the agent guessing about the purpose and format of each field.

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 ('Configure and validate') on a specific resource ('Zoho OAuth credentials'), and distinguishes itself from the sibling tools which all deal with portals, projects, tasks, or bugs. The prerequisite note reinforces its unique role, leaving no ambiguity about what it 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?

It explicitly states 'Must succeed before any other tool becomes usable', which tells the agent this is the first call to make. It doesn't mention when not to use it or alternative setup methods, but the instruction is clear enough for a prerequisite tool. The lack of explicit 'when not' is a minor gap given the obvious need.

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 burden, and it does disclose significant behavior: attachments are downloaded and returned inline, and no follow-up call is needed. It does not mention auth, rate limits, or error behavior, but for a read-focused tool the key operational trait is well communicated.

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

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

The description is a single sentence that front-loads the core purpose and packs the most important behavioral detail into the latter half without repeating information. It could be split into two sentences for readability, but there is no filler.

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

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

For a one-parameter read tool with no output schema, the description adequately conveys what the caller gets: details, comments, attachments, linked task, and inline image downloads. Minor gaps such as how non-image attachments are returned or error conditions do not undermine tool selection.

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

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

Schema description coverage is 0%, and the description does not explain bug_id, its format, or where it comes from. The phrase 'for a bug' adds little beyond the schema's own field title 'Bug Id,' so the description fails to compensate for the low coverage.

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

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

The description states a specific action and resource: get full context for a bug. It also lists the included contents (details, comments, attachments, linked task) and adds a distinguishing detail (image attachments returned inline), making it clearly distinct from sibling context tools like get_task_context or get_project_context.

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 this tool: when you need a bug's full context in one call, especially with visual attachments. However, it never explicitly names alternatives or states when not to use it, leaving the agent to infer the boundary from the sibling tool names and the word 'bug.'

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 return scope (all tasks under the milestone), but does not state whether the operation is read-only, whether large task counts are returned unbounded, or what the output structure looks like. The 'get' prefix implies read-only but this is not explicit.

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

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

The description is a single, front-loaded sentence with no filler. Every phrase earns its place, clearly conveying both the resource and the compositional scope.

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

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

For a one-parameter retrieval tool, this is minimally adequate, but with no output schema and no annotations, the description does not disclose return shape, potential pagination, or scale warnings. The nature of 'full context' is hinted but not fully specified.

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

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

Schema description coverage is 0% and the description does not elaborate on milestone_id beyond 'milestone'. The parameter name is self-explanatory, but the description adds no format, source, or expected value details. With zero schema coverage, the description fails to compensate.

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 resource (milestone) and scope ('metadata plus every task under it'), which distinguishes it from sibling tools like get_task_context and get_project_context. It lacks an explicit verb like 'retrieve' or 'list', but the intent 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 implies when to use this tool - when you need full context for a milestone including its tasks. However, it provides no explicit exclusions or comparisons to alternatives like get_task_context, leaving the agent to infer routing from the resource 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?

There are no annotations, so the description carries the full burden. It states the tool returns an 'overview' implying a read-only operation, but it does not explicitly confirm read-only behavior, mention any prerequisites (like a selected project), or describe error cases. While the description is not misleading, it lacks explicit behavioral details that an agent might need to infer safety and preconditions.

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 concise sentences, front-loaded with the tool's core function and then a usage example. There is no redundancy or filler. Every phrase contributes to understanding scope and applicability, achieving high conciseness with proper structure.

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

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

The description covers what the tool returns (list of components) and when to use it. It does not explicitly state whether a project must be selected beforehand, but the 'selected project' phrasing implies that context, and sibling selection tools exist. Given the low complexity (no parameters, no output schema), the description is largely complete, though it could have mentioned response format or potential 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?

The tool has zero parameters, so the schema provides no structural information to augment. Per the calibration, a zero-parameter tool gets a baseline of 4. The description adds no extra parameter semantics (none needed), but it does not contradict anything. Since all parameters are nonexistent, the description's clarity about the operation compensates adequately.

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 function: it provides a 'Full overview of the selected project' and lists the contained elements (details, tasklists, milestones, users, tags). This distinguishes it from sibling tools like get_tasklist_context or get_milestone_context, which focus on specific sub-entities. The verb 'get' plus resource 'project context' is specific and 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?

It explicitly gives a usage scenario: 'Use this for broad questions like 'what's the state of this project''. This conveys when to invoke the tool. However, it does not explicitly state when not to use it or point to alternatives, though the existence of focused sibling tools implies that. The guidance is clear but not exhaustive.

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 that image attachments are downloaded and returned inline, and that no follow-up call is needed, which is a valuable behavioral detail. It does not explicitly state that the operation is read-only or mention error cases, but the 'get' verb and the listing of returned content imply a safe read 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 a single sentence but front-loads the core purpose ('Full context for a task in one call') before listing the components and the inline-image behavior. It is efficient and not overly verbose, though slightly long; it earns a solid 4.

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

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

The description explains what the tool returns in detail (details, comments, subtasks, status history, attachments) and the inline image behavior. Since there is no output schema, this is necessary and sufficient for an agent to understand the result. It does not mention potential payload size or error handling, but for a read-only context tool, the information is complete enough.

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

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

Schema description coverage is 0%, and the description does not add any meaning beyond the schema's 'task_id' string. It neither explains the format, where to find the ID, nor any constraints. The purpose is inferable from the tool name, but the description fails to compensate for the low schema coverage.

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

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

The description clearly states the verb 'get' and the resource 'task context', and enumerates exactly what is included: details, comments, subtasks, status history, attachments, and inline images. It distinguishes itself from sibling context tools by emphasizing 'full context in one call' and the inline image behavior, making it unambiguous which tool to use for a task.

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 'full context for a task in one call' and 'no follow-up call needed', which gives clear context that this is the comprehensive task-specific tool. It does not explicitly name alternatives (e.g., get_project_context, get_bug_context) or state when not to use them, but the scope is clearly task-focused, so the guidance is adequate.

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 does disclose the response scope — metadata and every task, implying a potentially large read operation. It does not mention pagination, error handling, authentication, or performance, but the core read-only behavior is stated.

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 10-word sentence, front-loads the core value ('Full context for a tasklist'), and contains no unnecessary words 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 tool is simple (one parameter, no nested objects), but with no output schema or annotations, the description should cover return format and usage context. It explains the return content but omits when to use it and any behavioral caveats, leaving the agent to infer the rest.

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

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

Schema description coverage is 0%, and the description never mentions tasklist_id or its expected format. The parameter is largely self-explanatory from its name and type, so the omission is a moderate gap rather than a fatal one.

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 the resource (a tasklist) and the content returned (metadata plus every task), which clearly conveys a comprehensive retrieval operation. It does not explicitly distinguish itself from sibling context tools like get_project_context or get_task_context, but the resource-specific wording makes the scope 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?

No guidance is given on when to use this tool versus the other context getters, nor any exclusions, prerequisites, or alternatives. The only implied guidance comes from the tool name and the word '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. It mentions the OAuth prerequisite, which is a behavioral precondition, but does not disclose whether the operation is read-only, what side effects (if any) exist, or how the results are returned. The existence of sibling 'list_selected_portals' suggests a distinction, but this description does not clarify that it lists all portals versus selected ones. With zero annotation support, this is a significant gap.

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

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

Two short sentences with zero fluff. The action and resource are front-loaded, and the prerequisite is stated succinctly. 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 zero-parameter list tool with no output schema, the description covers the core purpose and a key prerequisite. It could add that the operation is read-only or specify the return format, but those are minor given the simplicity. The scope ('available to this account') adds useful context. It is mostly complete, though a note on output would be ideal.

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?

There are no parameters (0 params), so the schema is trivially covered. The description does not need to add parameter-specific details. Per the guidelines, with 0 params the baseline is 4, and there is nothing else to add.

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) and the specific resource (Zoho portals) and scopes it to 'this account'. It distinguishes itself from sibling tools like list_projects and list_users by naming the resource type. The verb 'List' is explicit and 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?

It provides a clear prerequisite ('Requires configure_oauth first'), which tells the agent the setup needed before calling. However, it does not explicitly contrast with alternative listing tools or state when not to use it, though the resource specificity makes the usage context clear. It gives a necessary condition but not explicit 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?

No annotations are present, so the description carries the full burden. It correctly implies a read-only operation ('List') and adds the OAuth prerequisite, which is useful behavioral context. However, it does not mention pagination, error behavior, or output shape, leaving moderate gaps for a tool with no annotation support.

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

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

Two sentences with no wasted words. The core action is front-loaded, and the prerequisite is placed efficiently after it. Every sentence adds value.

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

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

The tool is simple with one parameter, but there is no output schema and no annotations. The description covers the prerequisite and purpose but omits what exactly is returned and how the required portal_id should be obtained, leaving an agent to infer those details from sibling tools or runtime behavior.

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 description for portal_id (0% coverage). The description ties the parameter to 'in a portal,' giving some meaning, and the purpose sentence implies the output contains project_id. But it doesn't explain where portal_id comes from or any format constraints, so it only partially compensates for the schema 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 uses a specific verb and resource ('List all projects in a portal') and immediately clarifies the downstream purpose: picking a project_id for select_portal_and_project. This distinguishes it from sibling tools like list_portals, which lists portals, and select_portal_and_project, which selects rather than lists.

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

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

The description provides a clear prerequisite ('Requires configure_oauth first') and frames when the tool is useful ('so a project_id can be picked for select_portal_and_project'). It doesn't explicitly say when not to use it versus other siblings, but the context is strong enough for an agent to know when it applies.

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 burden. The verb 'List' clearly indicates a read-only operation, and the description specifies exactly what is returned (selected pairs and active one). It does not explicitly state there are no side effects, but the read-only nature is evident.

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 that is front-loaded with the core action ('List') and the precise scope ('every portal/project pair currently selected, and which one is active'). No wasted words; everything is essential.

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 read-only tool with no parameters and no output schema, the description is complete. It tells the agent exactly what information will be returned, which is sufficient for deciding whether to invoke 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, and schema coverage is 100% trivially. The baseline for 0 params is 4, and the description adds no parameter-specific information because none exist. It is accurate and complete for this aspect.

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 currently selected portal/project pairs and indicates which is active. This distinguishes it from sibling tools like list_portals and list_projects, which likely list all available options, by explicitly adding the 'currently selected' qualifier.

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 for querying the current selection state but does not explicitly contrast it with siblings. It does not say 'use this instead of list_portals when you need the active selection,' leaving the decision to inference. A clear alternative would improve routing.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only listing operation scoped to the current portal, but it does not disclose return shape, portal-selection requirements, or pagination behavior. For a simple list tool this is adequate, though not deeply transparent.

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

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

The description is a single, front-loaded sentence stating the action first, then the practical purpose. Every word earns its place, with no redundancy or 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 zero-parameter listing tool, the description covers the scope ('current portal') and the intended use case well. The lack of an output schema is partially mitigated by 'List tags' making the return nature clear, though a note about whether a portal must be selected would make it 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?

The input schema has zero properties and 100% schema coverage, so there are no parameters that need explanation. The description's mention of resolving tag IDs adds useful context beyond the 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 names a clear action and resource: 'List tags in the current portal.' This distinguishes the tool from siblings like list_portals, list_projects, and list_users by the specific resource being listed, with no need to inspect 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 provides a concrete use case: 'useful for resolving tag IDs on tasks/tasklists,' and scopes the operation to the current portal. It does not explicitly name alternatives or when-not-to-use cases, but no sibling overlaps with tags, so the guidance is sufficient.

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 conveys that this is a scoped read operation against the current portal and hints at the output's usefulness, but it does not describe return format, pagination, or any limitations. It is adequate but not richly transparent.

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

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

A single sentence with no wasted words. The core action is front-loaded and the purpose clause earns its place by explaining why an agent would call this tool.

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

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

For a zero-parameter listing tool, the description is nearly complete: an agent knows what to call and why. It does not explicitly state that a portal must already be selected, though the sibling tools (switch_portal, list_selected_portals) make that context discoverable.

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

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

The tool has zero parameters and schema coverage is 100%, so there is nothing for the description to add about arguments. The phrase 'current portal' refers to implicit context rather than parameters; the baseline for a no-parameter tool is appropriate.

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 — 'List users in the current portal' — and adds a concrete purpose ('useful for resolving owner names'). This clearly distinguishes it from sibling tools like list_portals, list_projects, and list_tags.

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 provides a clear use case (resolving owner names) and specifies the scope ('current portal'), so an agent knows when this list is relevant. It does not explicitly name alternatives or exclusions, but the sibling context makes the distinction straightforward.

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, and it does disclose a key non-obvious behavior: if the removed pair was active, another remaining selection becomes active. It does not mention failure modes or permissions, but for this simple state mutation the critical behavioral nuance is covered.

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

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

The description is a single focused sentence with a conditional follow-up that adds essential behavior. Every word earns its place, and the main action is 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 two-parameter tool with an output schema, the description is nearly complete: it states the operation, the object, and the active-selection fallback behavior. It does not explicitly state prerequisites such as 'the pair must already be selected,' but that is strongly implied by the phrase 'from the selected set.'

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 adds the useful semantic that portal_id and project_id together form a pair within the selected set, but it does not clarify where these IDs come from or any formatting constraints. The parameter names and titles are self-explanatory enough to make the description minimally viable.

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 ('Remove') with a precise resource ('one portal/project pair from the selected set'), making the operation unambiguous. It also implicitly differentiates from siblings like reset_selection by emphasizing removal of a single pair rather than clearing the entire selection.

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

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

The description gives clear context: use this when you need to remove one portal/project pair from the current selected set. It does not explicitly name alternatives or exclusions, such as 'for removing all, use reset_selection,' but the scope of the operation is clearly implied.

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

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

With no annotations, the description carries the full behavioral burden. It discloses both what is cleared (every portal/project selection) and what is preserved (OAuth config), which is meaningful side-effect information for a reset operation. It does not mention irreversibility or post-conditions, but the scope is simple enough that the stated behavior is largely sufficient.

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 that states the action, the scope, and the key preservation guarantee. Every word earns its place; there is no filler.

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

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

For a zero-parameter tool with an output schema, the description is nearly complete: it states the action, the scope, and what is not affected. A minor gap is not explicitly routing to remove_portal_selection for single-selection removal, but this is inferable from the sibling list.

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

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

The tool has zero parameters, so there is no parameter semantics burden. The description does not need to explain anything beyond the fact that no arguments are required, which the schema already conveys.

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

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

The description names a specific verb ('Clear') and resource ('every portal/project selection') and adds a key distinction ('without losing OAuth config'). It clearly separates this from sibling tools like remove_portal_selection and configure_oauth.

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: it clears all selections rather than just one, and it explicitly notes that OAuth configuration is preserved. It does not explicitly name alternatives or when not to use it, but the 'every' qualifier makes the intended use reasonably inferable from sibling names.

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 multiple portal/project pairs can be selected without losing earlier ones, that the new pair becomes active, and that OAuth configuration is required. It does not mention error behavior or whether selections persist, but the key stateful behavior is transparent.

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

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

The description is three sentences with no filler. It front-loads the primary action, then adds stateful behavior and alternatives, then the prerequisite. Every sentence contributes useful 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?

For a two-parameter selection tool with an output schema, the description covers purpose, state accumulation, navigation between selections, listing, and the required OAuth prerequisite. Nothing essential for invoking the tool correctly is missing.

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

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

Schema description coverage is 0%, so the description needed to compensate, but it only references 'portal/project' without explaining how to obtain or format portal_id and project_id. The parameter names are self-evident, but the description adds little beyond what the schema already shows.

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: 'Validate and select a portal/project, making it the active one.' It clearly distinguishes this from siblings by explaining that switch_portal is for moving between already-selected pairs and list_selected_portals is for viewing 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?

The description gives explicit when-to-use guidance: select new pairs here, use switch_portal to move between existing ones, and use list_selected_portals to see them. It also states the prerequisite, 'Requires configure_oauth first,' so an agent knows the required setup.

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 tool performs no re-validation and fails hard when the pair has not been selected. It does not detail side effects on the previous active context or auth requirements, but for a simple switch operation the disclosed behavior is meaningful and useful.

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 packs purpose, prerequisite, and failure mode with no wasted words. The dash-delimited clarification about no re-validation call earns its place by differentiating the tool from its sibling.

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 two-parameter state-switching tool with an output schema, the description covers the core actions, prerequisite, and failure behavior. It does not explain what happens to the previous active context or how to verify current selections, but those details are minor and partially discoverable via sibling tools like list_selected_portals.

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%, but the property titles 'Portal Id' and 'Project Id' are self-explanatory. The description adds important semantic constraint: the two IDs must represent an already-selected pair, and the failure condition ties both parameters to the prerequisite selection step.

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 ('Switch') and resource ('active portal/project'), and immediately distinguishes the tool from select_portal_and_project by noting it operates on an already-selected pair with no re-validation. This makes the tool's role unambiguous even 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 clearly states the prerequisite (must already be selected via select_portal_and_project) and the failure condition if that prerequisite is unmet. It does not explicitly say 'call select_portal_and_project first if not selected,' but the context is strong enough to guide correct usage.

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