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

Annotations already declare this is a non-read-only, destructive, open-world, non-idempotent mutation. The description does not explain what side effects occur (notifications, permissions, or what "destructive" means for a comment) or what the operation returns, so it adds little behavioral context beyond the annotations.

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, front-loaded, and free of filler. Its terseness is appropriate structurally, though it leaves important usage and parameter details unstated.

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 mutation tool with annotations but no output schema, the description is too sparse. It should at least clarify pageId, the required body format more concretely, and the practical consequences of adding a comment.

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 undocumented parameters. It usefully specifies that body uses storage XHTML, but pageId is left unexplained, and the exact XHTML expectations or constraints are not detailed.

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 ("Add comment") and adds the body format ("storage XHTML"). It clearly differs from the read-oriented sibling conf_get_comments, though it does not explain the relationship to other write 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?

There is no guidance on when to add a comment versus using other tools, no prerequisites such as authentication or page permissions, and no exclusions. The only usage-relevant detail is the required XHTML body format.

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?

The annotations already disclose readOnlyHint=false, destructiveHint=true, idempotentHint=false, and openWorldHint=true. The description adds only the word 'global' and says nothing about permissions, what happens if the label already exists, whether existing labels are affected, or what the return behavior is.

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

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

The description is extremely short and front-loaded, but it is under-specified rather than appropriately concise. Three words do not earn their place as a complete definition for a two-parameter mutation 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 required-parameter mutation tool with no output schema and a sibling set that includes label retrieval and page operations, the description is incomplete. It omits the page target, the effect on existing labels, and any behavioral or parameter detail an agent would need to call it correctly.

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

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

Schema description coverage is 0% for two required parameters, and the description does not explain pageId or label. It adds no meaning about parameter format, constraints, or purpose beyond the bare names in 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 an action ('Add') and a resource ('global label'), so the general purpose is inferable. However, it does not mention that labels are applied to a page (via pageId) or distinguish itself clearly from sibling tools such as conf_get_labels, leaving the target and effect somewhat vague.

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 explicit guidance on when to use this tool versus alternatives like conf_get_labels or conf_add_comment. The add-label intent is implied by the name and description, but no context, 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.

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered and the description adds no behavioral context on top. It does not say what state is returned (boolean? session details?), whether the check is cheap or triggers I/O against an open-world endpoint, or whether results are cached.

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 single phrase is front-loaded and free of waste, but it is sized below what the tool needs given it has no output schema and no sibling routing. Brevity here reads as under-specification rather than efficiency.

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 no output schema, the description is the only place an agent could learn what the auth status result looks like, and it says nothing about the return value or its possible states. For a status-check tool whose entire purpose is producing a piece of information, that is a material gap despite the simple zero-parameter interface.

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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline of 4 applies. Schema coverage is 100% and no enums or nested objects exist.

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?

"Check browser authentication" names a specific verb (check) and resource (browser authentication), so the agent knows this is a status read rather than a login. It stops short of differentiating from the sibling conf_browser_login, which is the natural confusion point.

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 guidance and no exclusion: the description never says to call this before browser-based operations, nor that conf_browser_login should be used when the check fails. The relationship to the sibling login tool is left entirely to inference.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. Beyond that the description adds nothing: it doesn't say whether the call blocks until the user completes SSO, whether it returns a URL or a status, how failure/timeout behaves, or that a human must interact with the browser — all material for an open-world, side-effecting UI action. No contradiction with readOnlyHint (no Confluence data is modified), but disclosure is thin.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity is also the source of the missing behavioral detail rather than a sign of tight editing.

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 interactive SSO trigger with no output schema and no parameters, the description should explain the interaction model (blocking vs. non-blocking, human-in-the-loop, what to do after) and its relationship to conf_browser_auth_status. None of that is present, leaving the agent to guess how to sequence the call.

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 takes zero parameters and the empty object schema is exhaustive, so there is nothing for the description to disambiguate. Baseline 4 applies; the description correctly implies the call needs no arguments.

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 pairs a specific verb ("Open browser") with a specific resource/flow ("Confluence SSO sign-in"), so an agent immediately knows this initiates an interactive sign-in rather than a data query. It does not, however, mention the closely related sibling conf_browser_auth_status, which is the natural companion tool for checking whether sign-in is needed or succeeded.

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 explicit when-to-use guidance, no statement of prerequisites (a browser-capable environment, human interaction), and no pointer to conf_browser_auth_status for verifying state afterward. Usage is only implied by the name and the word "sign-in".

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?

Annotations already declare destructiveHint=true, openWorldHint=true and idempotentHint=false, so the safety profile is partly known. The description adds only the body-format requirement and says nothing about permissions required, what happens if the title already exists, how parentId affects placement, or what is returned (page id), which matters for a non-idempotent write.

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 clause with no wasted words, and the most failure-prone constraint (body must be storage XHTML) is placed up front. The terseness is under-specification rather than verbosity, so it scores well here but poorly on completeness.

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 non-idempotent, destructive create operation with four undocumented parameters and no output schema, the description says far too little. An agent still cannot tell what the call returns or how parentId and spaceKey should be formed.

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 carry the meaning of all four parameters and does not. It clarifies the format of body only; spaceKey (key vs numeric id), title, and especially the optional parentId (omitting it presumably creates a top-level page) are entirely undocumented.

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 ("Create page"), which an agent can distinguish from the sibling conf_update_page and conf_delete_page. It does not explicitly name how it differs from those siblings, but the create/update/delete split is self-evident from the verb.

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 statement of when to use this tool versus conf_update_page, nor any prerequisite context (edit permission on the target space, behavior on duplicate titles). The only guidance is a body-format constraint, which is a usage constraint but not when-to-use 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?

The annotations already declare destructiveHint=true, idempotentHint=false and openWorldHint=true, so the safety profile is largely covered. The phrase "move to trash" does add real value by implying a recoverable soft delete rather than a permanent purge, but the description says nothing about permissions required, whether child pages are affected, or how the page can be restored.

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 five-word sentence with no filler and the action front-loaded. It is efficient, though the brevity shades into under-specification rather than tight, informative concision.

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 destructive, non-idempotent mutation with no output schema and 0% schema coverage, the description leaves out too much: permissions, effect on child pages, and recoverability/restore path. The annotations carry the risk signal, but the description does not fill the remaining gaps an agent needs before invoking 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?

Schema description coverage is 0% and the description does not explain pageId at all, so the description fails to compensate for the coverage gap. The single parameter name is largely self-evident, which keeps this from being a 1, but no format or sourcing guidance is added.

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?

"Move a page to trash" states a specific verb (move to trash) and resource (page), which reads as a soft delete and is distinguishable from conf_update_page or conf_get_page. It stops short of naming any sibling or clarifying the boundary with conf_update_page, so it is clear but not fully differentiated.

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 versus conf_update_page, and no mention of prerequisites such as ownership or admin rights. It also doesn't say whether this is the only deletion path or whether a permanent-delete variant exists.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the entire safety profile is provided structurally and the description restates none of it. The description contributes no behavior of its own: nothing about pagination defaults, whether children are recursively expanded or direct-only, ordering, or what happens for an invalid or inaccessible pageId.

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?

At five words there is no waste and the purpose is front-loaded, so it is not poorly structured. The problem is under-specification rather than verbosity: brevity here costs clarity instead of buying it, so it does not merit a high conciseness 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?

With no output schema, no annotation-independent detail, and 0% schema description coverage over limit/start, the definition is too thin for the tool's actual surface. An agent cannot tell whether children are direct-only or recursive, how pagination terminates, or how to interpret an empty result, all of which matter for correct invocation.

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

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

Schema description coverage is 0% across three parameters, so the description is the only place semantics could be added and it adds very little. '(one page)' weakly signals that pageId identifies a single parent, but limit and start are never mentioned, leaving pagination behavior entirely undocumented. The gaps are real but the parameter names are largely self-explanatory, keeping this at a minimum-viable 3 rather than lower.

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 verb+resource ('List child pages') is identifiable, and '(one page)' hints the result is scoped to a single parent rather than the whole space, which loosely separates it from conf_search and conf_get_page. But the phrasing is compressed to the point of ambiguity: it never names the parent page or says what a 'child page' is in this hierarchy, so an agent must infer the semantics from the parameter name 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?

There is no when-to-use guidance and no reference to any of the many plausible alternatives (conf_get_page for a single page, conf_search for lookup, conf_get_spaces for hierarchy). An agent must decide for itself when child-listing beats a direct page fetch, with nothing in the description to arbitrate.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The only behavioral claim the description makes is "(one page)", which gestures at a pagination boundary but never says whether results are truncated, what the default limit is, or how to page further — leaving the one piece of genuinely new behavior ambiguous.

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?

At five words it is certainly front-loaded and contains no filler, but the brevity crosses into under-specification rather than efficiency. The parenthetical is the only structural addition and it introduces ambiguity instead of removing it.

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

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

For a three-parameter listing tool with no output schema and 0% schema description coverage, the description does far too little: no return-shape hint, no pagination contract, no mention of ordering or permissions. Annotations cover the safety profile, but nothing covers how to call it correctly.

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

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

Schema description coverage is 0% across three parameters (pageId, limit, start), so the description carries the full burden of explaining them. It only implicitly covers pageId via the word "page" and says nothing about limit or start, so an agent gets no help on the two pagination parameters that matter most.

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 verb ("List") and a resource ("page comments"), which distinguishes it from the write-side sibling conf_add_comment. However, the parenthetical "(one page)" is ambiguous — it could mean comments on a single Confluence page or a single page of paginated results, and the description never resolves which. The core purpose is guessable but not stated with precision.

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 alternatives such as conf_get_page or conf_add_comment, nor any prerequisite or context statement. The agent must infer usage entirely from the name and the sibling list.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is fully covered. The description adds nothing beyond them: it does not say what happens when no credentials exist (error vs. unauthenticated payload) or what the response looks like, so it contributes no behavioral context of its own.

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?

It is a single front-loaded phrase with zero waste, which is good, but the brevity crosses into under-specification: three words omit any usage context or return information and would have benefited from one clarifying sentence.

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, read-only identity tool with no output schema, the description is minimally sufficient, and annotations carry the safety profile. It is still incomplete on the two things an agent cannot infer: the returned fields and behavior under missing or expired authentication.

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 takes zero parameters, so there are no parameter semantics that the description must explain. Baseline for a parameterless tool 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?

"Get authenticated user" names a specific verb and resource, and it is distinguishable from the nearby conf_browser_auth_status sibling, which concerns auth state rather than identity. It stops short of naming that sibling or saying what the returned user record contains.

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

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

The use case (identify who the current credentials belong to) is strongly implied, but there is no explicit when-to-use, no when-not, and no routing to alternatives such as conf_browser_auth_status when the agent only needs to know whether it is logged in.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered. The only added context is the cryptic "(one page)"; the description says nothing about pagination continuation, rate limits, or what happens when start exceeds the result count.

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?

Four words with no wasted text, but the brevity comes at the cost of clarity; the parenthetical is under-specified rather than informative. Front-loading is fine, but there is essentially nothing to front-load.

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 no output schema, no parameter descriptions, and a read-open-world tool that returns paginated data, the agent has no way to know the response shape or how to detect and fetch further pages. The description does not fill any of these 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% for three parameters (pageId, start, limit), so the description must compensate. It only hints at paging with "one page" and never clarifies that pageId is the Confluence page whose labels are listed, nor how start/limit behave together (defaults 0/25, max 100).

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?

"List labels" names a verb and resource, but the parenthetical "(one page)" is ambiguous: it could mean pagination (one page of results) or labels belonging to one Confluence page. An agent can infer listing vs. the sibling conf_add_label, but cannot tell the scope precisely.

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 versus conf_add_label, conf_search, or conf_get_page. Usage is only implied by the verb "List", with no prerequisites or exclusions 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds genuinely new behavioral context by disclosing the return payload shape (storage-format XHTML body, version, ancestors). It says nothing about permissions, access errors, or pagination/size limits for large pages.

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 compact phrase with no wasted words, front-loaded with the verb and resource. It is telegraphic to the point of being slightly clipped, but nothing is redundant.

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 one-parameter read with full annotation coverage and no output schema, this is nearly adequate: it does describe the salient return contents. The gap is the pageId input format and any hint about page-body size or truncation, which an agent cannot recover from the structured fields.

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 single pageId parameter is undocumented in both schema and description. The description does not say whether pageId is a numeric ID, a UUID, or a title, which is the one piece of information an agent actually needs to invoke this correctly.

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 ('Read') and resource ('page'), and adds that the result includes the storage XHTML body, version, and ancestors, which distinguishes it from sibling reads like conf_get_children or conf_search. It stops short of explicitly naming those siblings, so it is clear but not fully differentiated.

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 guidance: nothing says to use this for fetching a single page by ID rather than conf_search, conf_get_children, or conf_get_space. The only hint is the word 'Read' and the singular 'page', which leaves selection against a 14-sibling list to inference.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered structurally. The description adds nothing beyond that - no note on whether a missing space errors or returns empty, no auth/prerequisite context, despite openWorldHint implying network access.

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 words with no filler and the resource is front-loaded after the verb. However, this is terseness rather than effective conciseness - the brevity comes at the cost of nearly all useful information.

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 trivial (one required param, no output schema, annotations present), so the bar is low, but the description still omits the spaceKey format and any sense of what the returned "details" comprise. It is minimally sufficient for an agent that already knows Confluence conventions, and thin for one that does not.

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 spaceKey is an undocumented string in both the schema and the description. The description does not explain what a space key looks like (name vs. identifier) or give an example, which is exactly the gap it should fill for a single required 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?

"Get space details" states a verb (get) and a resource (space), so the basic action is clear. But "details" is vague about what is returned, and nothing distinguishes it from the sibling conf_get_spaces (plural) or conf_get_page, which an agent must disambiguate on its own.

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 when-to-use guidance at all. With a near-identical sibling (conf_get_spaces) in the toolset, the description never says when to fetch a single space versus list all spaces, leaving the agent to infer from the name alone.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is fully covered structurally. The description adds one real behavioral fact beyond that: results are paginated to a single page. It stops short of explaining how to detect more pages or what the response contains.

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?

It is short and front-loaded with the verb and resource, so nothing is wasted. But the brevity crosses into under-specification: the four-word parenthetical is doing work it cannot support, and no sentence earns its place by explaining pagination.

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 paginated list tool with zero schema descriptions and no output schema, the description should explain the paging model and what a space record looks like. Neither is present, so an agent knows it lists spaces but not how to page through them or interpret the result.

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

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

Schema description coverage is 0%, so both parameters (limit with default 25 and max 100, start with default 0) are undocumented anywhere. The description's "(one page)" gesture toward pagination does not explain that limit controls page size or that start is an offset, leaving the agent to infer the paging contract from bare integer types.

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?

"List spaces" names a specific verb and resource, so the basic operation is identifiable. However, the parenthetical "(one page)" is cryptic, and the description never distinguishes this from the singular sibling conf_get_space or from conf_search, leaving the agent to infer which listing tool to pick.

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 guidance, no mention of when to prefer conf_get_space or conf_search, and no prerequisites. The only usage hint is the ambiguous "(one page)", which implies a paging loop without saying how to continue it.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds genuinely useful behavior beyond that — results are a single page with pagination metadata — but says nothing about authorization requirements, result size limits, or whether indexing delays affect freshness.

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 compact sentence with the action front-loaded and no filler. Its brevity is efficient, though the terseness contributes to the documentation gaps noted elsewhere.

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 search tool whose required parameter is an entire query language and which has no output schema, the definition is thin: no CQL syntax hint, no description of the returned page or pagination token, and no guidance on paging through results. The annotations cover safety but not the operational detail an agent needs to call 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 description coverage is 0% across three parameters, so the description carries the full burden and largely fails: it never explains CQL syntax or capabilities, and does not connect "one page with pagination metadata" to the limit/start parameters or their defaults and bounds. The only schema-adjacent hint is the word "pagination".

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 gives a specific verb and resource ("Search content using CQL") and names the query mechanism, which separates it from the fetch-oriented siblings like conf_get_page and conf_get_children. It does not define what CQL is or what content types are searchable, but the core purpose 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?

There is no explicit when-to-use guidance: nothing says when to search versus walking the hierarchy with conf_get_children or fetching a known page with conf_get_page. Usage is only implied by the verb "Search", leaving the agent to infer the 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?

Annotations already declare the mutation is destructive, non-idempotent, and open-world, so the safety profile is covered. The description adds meaningful context beyond that: conflicts surface as errors with no automatic retry, implying optimistic concurrency. It still omits what a destructive update actually overwrites (e.g. whether title/body replace existing content wholesale) and what the conflict error looks like.

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 waste; the version prerequisite is front-loaded ahead of the conflict behavior. Nothing could be removed without losing signal.

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 destructive, irrecoverable update with four required parameters at 0% schema coverage and no output schema, the description is thin. An agent gets the concurrency rule but not replacement semantics, permission requirements, or error shape — the things most likely to cause a bad call.

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 carry the burden and mostly does not. It explains only currentVersion (must come from get_page), leaving pageId, title, and body undocumented — notably whether body is storage-format markup and whether omitted content is cleared.

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 ("Update page") plus the version constraint that governs the operation. It is clearly distinguishable from siblings like conf_create_page and conf_delete_page, though it never names an alternative explicitly.

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?

Implies a workflow precondition by telling the agent to use the version returned by get_page, which is genuinely useful for correct invocation. However, there is no explicit when-to-use versus when-not guidance, no mention of prerequisites like edit permissions, and no routing to sibling tools for related tasks.

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