mcp-atlassian

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation4/5
Most tools are clearly separated by resource and action, and detailed descriptions clarify singular/plural and inline/regular variants. A few pairs like get_page_images vs download_content_attachments and get_page_children vs get_space_page_tree could be confused, but the descriptions provide enough context to avoid misselection.
Naming Consistency4/5
All tools share a confluence_ prefix and generally follow a verb_noun structure. The pattern is slightly inconsistent because list is only used for list_page_templates while other collection retrievals use get_ (get_comments, get_attachments, get_labels), and confluence_search omits a noun.
Tool Count2/5
35 tools is a large surface for an MCP server, exceeding the comfortable well-scoped range. While most operations are legitimate, batching variants and niche endpoints like upload_attachments, download_content_attachments, page_views, and permission checks make the set feel heavy and would benefit from consolidation.
Completeness3/5
Page, attachment, and template coverage is strong, including move, copy, restrictions, history, and diff operations. However, comment lifecycle is incomplete with no update/delete comment tools, label deletion is missing, and there is no tool to list spaces or access space metadata; additionally, despite the Atlassian name, Jira is entirely absent.
Average 3.9/5 across 35 of 35 tools scored. Lowest: 2.8/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 4 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations provide destructiveHint=true, indicating mutation, but the description adds no behavioral detail beyond that. It does not disclose whether omitted fields preserve existing content, whether a new version is created, or what side effects update may have. Since annotations already carry the destructive signal, the description contributes almost nothing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely short, which is concise, but it is effectively a restatement of the tool name and title. For a tool with 13 parameters and multiple sibling operations, a one-sentence description that adds no constraints or usage context is under-specified rather than efficiently concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The rich input schema and output schema carry most of the contextual load, making this minimally viable. However, the description fails to clarify important update semantics, such as whether omitted content is preserved or cleared, or how this update interacts with page versioning. It is adequate only because the schema fills in most operational details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the parameter descriptions already define every field including defaults, formats, and mutual exclusions. The description adds no parameter-level meaning, which is acceptable given the schema is self-sufficient. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('update') and resource ('existing Confluence page'), which is understandable on its own. However, it does not distinguish itself from the sibling tool 'confluence_update_page_section', leaving some ambiguity about scope (full page vs section).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus create_page, update_page_section, move_page, or delete_page. The description simply says 'update an existing Confluence page' with no context about prerequisites, alternatives, or situations where a different sibling is preferred.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes this is a safe read, and the description does not contradict it. However, the description adds no behavioral detail beyond the basic retrieval action—no mention of pagination, comment scope (top-level vs replies vs inline), or ordering. With annotations present, the bar is lower, but the description still contributes nothing beyond what annotations and the name already suggest.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One short sentence with no extraneous wording; the verb and target are front-loaded. It is appropriately concise for a simple getter, though the brevity contributes to the missing sibling differentiation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one parameter, a detailed schema, and an output schema, the structural context is strong. However, the presence of confluence_get_inline_comments among siblings makes the missing distinction between regular and inline comments a real gap for tool selection, and no usage exclusions are stated. Therefore the description is not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the page_id property already includes a rich description with an example URL-to-ID parse. The tool description adds no parameter-level information, aligning with the baseline of 3 for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a clear verb+resource combination: 'Get comments' for 'a specific Confluence page.' However, it does not differentiate from the sibling confluence_get_inline_comments, leaving ambiguity about whether inline comments are included.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives. It does not mention that confluence_get_inline_comments is for a different comment type, nor any conditions for choosing this tool. The only hint is the generic page scoping.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare destructiveHint=false, so the description carries most of the behavioral disclosure burden. It simply says 'add a comment' without explaining whether this creates a top-level comment, whether it replaces or complements inline/reply comments, what side effects occur, or whether special permissions are required. This is thin for a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no filler or repetition. It is appropriately sized for a simple two-parameter tool and front-loads the primary action immediately.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, parameters are fully described by the schema, and an output schema exists, so return-value documentation is not required. However, the description omits usage context relative to closely related sibling tools, which leaves an agent without enough guidance to reliably choose this tool over reply_to_comment or add_inline_comment.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both page_id and body are already documented. The description adds no additional parameter meaning, which is acceptable because the schema does the heavy lifting. The baseline of 3 applies here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb ('Add'), resource ('a comment'), and target ('a Confluence page'), so an agent knows the basic operation. It does not explicitly distinguish from sibling tools like confluence_reply_to_comment or confluence_add_inline_comment, 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.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as reply_to_comment or add_inline_comment. It does not state whether this creates a top-level comment, nor does it mention any exclusions or prerequisites. The agent must infer usage from the tool name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description only restates the action already implied by the title and provides no disclosure about effects, permissions, or response behavior. Annotations provide only destructiveHint=false and no readOnlyHint, so the description carries most of the behavioral disclosure burden and does not meet it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words and the key action is front-loaded. It is appropriately concise, though it adds little beyond the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with full schema descriptions and an output schema, the minimal information needed to invoke it is present. However, contextual completeness suffers from missing usage guidance relative to sibling comment tools and from the sparse behavioral disclosure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and both parameters (comment_id, body) are already documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Reply') and resource ('existing comment thread on a Confluence page'), making the core action clear. It does not explicitly name or contrast sibling tools like confluence_add_comment or confluence_add_inline_comment, so it stops short of full sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'existing comment thread' implies the tool is intended for replying to an existing thread rather than starting a new top-level comment or inline comment. However, there is no explicit guidance about when to choose this tool over alternatives such as confluence_add_comment or confluence_add_inline_comment.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The destructiveHint annotation already marks this as destructive, and the description adds no behavioral context beyond the core function. It does not disclose side effects like URL changes, child page implications, permission requirements, or irreversibility, so it adds no value beyond what annotations already signal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence with no unnecessary words. It front-loads the primary action and destination, making it easy to scan and quickly understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The schema and output schema cover parameters and return values, and the destructiveHint annotation covers safety signaling. However, the description lacks usage guidance and behavioral side-effect detail, leaving an agent without enough context to choose this tool confidently among many page-related siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema fully documents all parameters. The description's phrase 'new parent or space' loosely maps to target_parent_id and target_space_key but provides no additional semantic detail beyond what the schema already states.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Move') and resource ('a Confluence page') and clearly identifies the destination ('a new parent or space'). It distinguishes itself from sibling tools like copy, delete, or create by precisely describing a relocation operation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives such as confluence_copy_page or confluence_update_page. It does not mention prerequisites, exclusions, or scenarios where a different sibling tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only include destructiveHint: false, which correctly signals this is not destructive. The description adds little behavioral context beyond 'create' — it does not disclose that pages may be visible immediately, that permissions may govern creation, that Live Doc subtype is cloud-only (though schema says it), or what happens with duplicate titles. With weak annotations, the description carries some burden and only partially meets it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one short, direct sentence: 'Create a new Confluence page.' It is concise and front-loaded. It earns its place but is almost too minimal, providing no extra context beyond the title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 12 parameters, a rich schema, and an output schema, the description is not required to explain return values or parameters. However, it lacks guidance on when to use this tool versus create_page_from_template or copy_page, and lacks notes on prerequisites like space existence and permissions. It is minimally viable but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already thoroughly documents every parameter. The description itself adds no additional parameter meaning. Baseline 3 is appropriate because the schema does the heavy lifting; the description does not need to repeat it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Create a new Confluence page.' It is clear and distinguishes from siblings like update_page or delete_page. It could be slightly improved by noting it creates a standalone page (vs create_page_from_template or copy_page), but the core purpose is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not provide explicit when-to-use guidance or mention alternatives. However, the schema gives substantial context, including mutually exclusive content vs content_file and format options. Sibling names imply alternatives like create_page_from_template, but the description itself does not state when to choose this over those. This is a moderate gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already covers the safety profile and the description is consistent with it. The description adds minimal behavioral context ('all' implies complete list, 'inline' defines scope) but does not disclose return-volume behavior, pagination, or whether resolved/hidden comments are included. This is acceptable but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that delivers the action, the resource, and the scope with zero filler. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read-only tool with an output schema and a readOnlyHint annotation, the description is nearly sufficient. A brief note on what 'inline' excludes (e.g., top-level page comments) would fully close the loop, but nothing essential is missing for invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents page_id. The description adds no parameter-level detail beyond what the schema provides, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and resource ('inline comments' for a 'Confluence page'), and the qualifier 'inline' distinguishes this from generic comment tools among the siblings. It is clear about scope, though it does not explicitly name a sibling it differs from.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as a general comments tool or other page-related readers. There are no usage conditions, exclusions, or prerequisite notes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes that this is a safe read operation, and the description is consistent with that. It adds minor context by mentioning folders and page scoping, but does not disclose traits like direct-children-only behavior or pagination semantics beyond what the schema already covers.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler or redundancy. It is front-loaded with the action and resource, making the core operation immediately understandable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With readOnlyHint, a fully documented schema, and an output schema available, the definition is operationally self-sufficient. The main missing piece is guidance for choosing this tool over sibling tools, but that gap is already captured in the usage_guidelines dimension.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All 7 parameters have descriptions in the schema, so schema coverage is 100%, which sets the baseline at 3. The description itself adds no parameter-level detail, so it provides no additional value beyond the structured schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (get), resource (child pages and folders), and scope (specific Confluence page). It is clear what the tool does, though it does not explicitly distinguish itself from sibling tools like get_space_page_tree.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. An agent must infer usage from the tool name and generic intent, which is especially weak given the large set of sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the read-only safety profile is covered. The description adds that it returns a 'hasPermission' boolean and is Cloud-only, but it does not disclose error behavior, permission-check edge cases, or what happens for invalid identifiers. This provides modest value beyond the annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the core purpose, followed by endpoint, Cloud-only caveat, and return type. Each sentence is relevant, though the endpoint and return-type details are partially redundant with the schema and output schema. It is appropriately sized but not maximally tight.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only permission-check tool, the description covers purpose, availability, response shape, and endpoint, while the schema fully documents all four parameters. It does not mention error cases or behavior on missing content, but for this simple contract those are not essential. Overall it is sufficiently complete for an agent to call it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters, defaults, and examples. The description adds no new parameter-level meaning beyond restating the user/group and operation concepts. The baseline of 3 applies because the schema carries the parameter documentation burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and object: 'Check whether a user or group can perform an operation on specific content.' This clearly identifies the tool's function and distinguishes it from sibling permission tools by focusing on an operation-level check rather than listing restrictions. However, it does not explicitly contrast itself with similar siblings like get_page_restrictions or get_space_permissions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear usage boundary: the tool is only available for Confluence Cloud and explicitly warns that Server/Data Center instances use different permission APIs. It implies when to use the tool from the purpose statement, but it does not name or route to alternative sibling tools. This is clear context with an important exclusion, though not fully explicit alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already covers the safety profile, and the description's 'Get a historical version' adds mild context that this returns non-current content. It does not disclose additional behavioral traits such as response shape or edge cases, but the schema and output schema carry much of that burden, and there is no contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single focused sentence with no filler and the core action front-loaded. It is appropriately concise, though it relies entirely on the schema for parameter-level details, which is acceptable given the schema's richness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 fully documented parameters and an output schema, the description provides the essential purpose an agent needs. It could be slightly improved by naming sibling alternatives or explicitly stating when to choose this tool, but nothing critical is missing for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with detailed descriptions for page_id (including an example URL), version (minimum and role), and convert_to_markdown (including token usage caveat). The tool description itself adds no parameter-level meaning, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get'), resource ('historical version of a specific Confluence page'), and clearly distinguishes the tool from siblings like confluence_get_page (current version) and confluence_get_page_diff (version comparison). It is unambiguous about what the tool retrieves.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool—when a historical version is needed—but gives no explicit guidance about alternatives or when not to use it. It does not mention related tools like confluence_get_page for current content or confluence_get_page_diff for comparing versions, so an agent must infer routing from the sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already signal destructiveHint=true, so the mutation aspect is covered. The description adds the useful behavioral detail that the comment is anchored to a text selection, but it does not disclose side effects, anchoring failure behavior, or permission requirements. There is no direct contradiction with 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence with no wasted words. It communicates the essential behavior immediately and every word contributes to understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a relatively simple creation tool with a full output schema and 100% parameter coverage, the description sufficiently captures the core action and anchoring model. It lacks only explicit guidance about alternative tools and edge-case matching behavior, which are minor gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters already carry adequate documentation. The description only restates the text_selection concept and adds no new meaning beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Add') and a specific resource ('inline comment') with an explicit anchoring constraint ('text selection on a page'). This clearly distinguishes it from sibling tools like confluence_add_comment and makes the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool — when commenting on a specific passage of text — but it never explicitly states why to prefer it over confluence_add_comment or confluence_reply_to_comment, and provides no exclusions or alternative routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide destructiveHint=false, so the description carries the behavioral load. It adds genuinely useful context beyond that: Cloud-only availability, that the template body is fetched and inserted as storage-format content, and that the created page remains editable afterward. It does not cover permissions or failure scenarios, but it gives a solid behavioral picture for a create tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences with no filler. The first sentence gives the core operation, the second states the Cloud-only limitation, and the third points to the subsequent editing tool. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given an existing output schema and only a destructiveHint annotation, the description covers the essential context: what the tool does, the Cloud-only restriction, and the follow-up editing path. A note about prerequisites or permissions would be a minor enhancement, but the definition is complete enough for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents title, parent_id, space_key, and template_id. The description's mention of the 'named template' does not add extra parameter-level meaning, so the 100%-coverage baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the operation creates a new Cloud page pre-populated with a template's body, and it notes the storage-format content. This distinguishes it from the generic confluence_create_page and related page-composition tools, though it does not explicitly name a sibling or draw a contrast with it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It communicates a hard environment constraint (Confluence Cloud only) and a follow-up edit path via confluence_update_page, which implies when the tool is relevant. It stops short of explicitly saying when to use this over confluence_create_page or how to source a valid template_id, so the usage guidance remains mainly implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The destructiveHint annotation already communicates that this is a destructive operation. The description adds only 'existing' to indicate the page must already exist, but it does not elaborate on consequences such as permanence, cascade deletion, or permission requirements. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly scoped sentence with every word earning its place. It opens with the action verb and names the target resource without unnecessary detail.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter delete operation, the description combined with the destructive annotation and output schema is nearly complete. A brief note about irreversible effects or cascading deletion of child pages would improve it, but the essentials are present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%—the page_id parameter is fully described as the ID of the page to delete. The description provides no additional information about the parameter format, source, or special considerations, so it adds no value beyond the schema. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Delete an existing Confluence page.' This is clearly distinct from sibling tools like create_page, update_page, and delete_attachment, so an agent can immediately understand what operation this tool performs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage context is implied by the name and description: use this tool when you want to delete a particular page. However, there is no explicit guidance about when not to use it or reference to alternatives such as confluence_delete_attachment for attachments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already mark the tool as read-only (readOnlyHint=true), and the description is consistent with that. It adds the scope of content types but does not disclose other behavioral details such as pagination, response format, or error handling; however, an output schema exists to cover some of that burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no redundant words. It immediately states the action and the resource types, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter read-only tool with a full input schema and an output schema, the description is nearly sufficient. It could have added a note about the label return structure or how this differs from fetching the full page, but nothing critical is missing for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% parameter coverage, including detailed explanations of the page_id format for pages vs attachments and support for any label-capable content. The description adds nothing about parameters beyond what the schema already documents, so a baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Get labels') on a well-defined resource ('Confluence content') and enumerates valid content types (pages, blog posts, attachments). It clearly differentiates from siblings like confluence_add_label and other content-fetching tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for retrieving labels from Confluence content, but it never explicitly tells the agent when to choose this over alternatives like confluence_get_page, nor does it state when not to use it. Usage is inferred rather than explicitly guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already signals a safe read operation, and the description adds the Cloud-only availability note. It does not describe any quirks of the analytics data, such as aggregation period or permission requirements, but for a read-only analytics tool this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the core purpose, followed by a relevant availability note. Every sentence earns its place, and there is no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, has a complete input schema, and an output schema exists, so the description does not need to explain return values. The Cloud-only note is the key missing context and is provided. Minor gaps like exact view-count semantics are not critical given the output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with page_id fully explained via a concrete URL example and include_title having a clear default and description. The tool description adds no parameter-specific nuance, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the specific action ('Get view statistics') and resource ('Confluence page'), making it clear what the tool does. It does not explicitly differentiate from siblings like confluence_get_page or confluence_get_page_history, but the focus on view statistics is distinctive enough.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly notes that the tool is only available for Confluence Cloud and not for Server/Data Center instances, giving clear when-not-to-use guidance. It does not name alternative tools for on-premise instances, but the platform limitation is directly useful for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already include destructiveHint=false, so the non-destructive nature is covered. The description adds the acceptable target types (pages, blog posts, attachments), but it does not disclose details like duplicate-label handling or permission requirements. This is acceptable for a simple add operation, but not exceptionally transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core operation, and the bullet list adds practical context without excessive padding. It is slightly more verbose than strictly necessary, but each bullet earns its place by clarifying real use cases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with a fully described schema and an output schema present, the description covers the target types and use cases adequately. A note about duplicate-label behavior or idempotency would make it fully complete, but nothing critical is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters well. The description reinforces why labels are useful, but it does not add meaningful parameter semantics beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Add label to Confluence content (pages, blog posts, or attachments).' This clearly identifies the operation and distinguishes it from read-only label retrieval tools like confluence_get_labels and from other content mutations like confluence_add_comment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'Useful for' bullets provide concrete application contexts such as categorizing attachments, tracking status, and filtering content. It does not explicitly name alternative tools or state when not to use it, but the intended use cases are clear enough for an agent to decide correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description discloses meaningful behavior: attachments are base64-encoded embedded resources, filesystem access is not required, and files over 50 MB are skipped with an error entry in the summary. This gives the agent important execution expectations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short, front-loaded with the core purpose, and every sentence adds value. It explains the format and the size limit without unnecessary fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With only one parameter and no output schema, the description does a good job explaining the return behavior, including the base64 format and the skip/error handling for large files. It lacks only minor details like the exact structure of the summary, but it is sufficient for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema already documents content_id with an example and explanation of what it refers to. The tool description adds no additional parameter meaning beyond what the schema provides, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Download all attachments'), the resource ('Confluence content item'), and the output format ('embedded resources'). It also distinguishes itself from the sibling confluence_download_attachment by emphasizing 'all attachments', so an agent can tell them apart.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description conveys that this tool is for retrieving all attachments for a content item, so basic usage context is implied. However, it does not explicitly contrast with alternatives like confluence_download_attachment or confluence_get_attachments, nor does it state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already covers the safety profile. The description adds the 'unified diff' format detail, which is a behavioral trait, but does not disclose additional traits such as version ordering direction, pagination, or error behavior. With annotations present, this is adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-formed sentence with zero redundant words. It front-loads the core action and resource with no filler, earning its place completely.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
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 three fully documented parameters and an output schema, the description is nearly complete. The only minor gap is that it doesn't explicitly clarify the direction of the diff (from from_version to to_version), but the schema field names and descriptions largely convey this.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all three parameters (page_id, from_version, to_version). The description adds no parameter-level meaning beyond what the schema provides, hence the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get') and a clearly defined resource ('a unified diff between two versions of a Confluence page'). This distinguishes it from all sibling tools, none of which claim to produce diffs between versions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies clear usage context: the agent should select this tool when it needs to compare two versions of a Confluence page. It doesn't explicitly name alternatives or exclusions, but the context is straightforward given the tool name and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already marks this as a safe read operation. The description adds context beyond that by specifying 'Cloud' scope and by clarifying that the returned body is in storage format, which is useful for an agent deciding if the output format matches its needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words. It front-loads the action and resource, then delivers the key extra detail about the storage-format body without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter read-only tool with an output schema and a readOnlyHint annotation, the description covers what is needed: the resource, the identifier, the Cloud scope, and the body format. Nothing significant is missing for an agent to invoke this correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage for the only parameter, template_id, so the schema already explains that it is the ID of the template to retrieve. The description's 'by ID' phrase reinforces this but adds no further semantic detail, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Get' with a clear resource, 'Cloud page template by ID,' and adds the detail that the storage-format body is included. This distinguishes it from siblings like list_page_templates (listing) and get_page (regular pages rather than templates).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the usage: retrieve a Cloud page template when you have its ID. However, it does not explicitly state when to prefer this tool over alternatives, such as using list_page_templates to find a template ID or get_page for ordinary pages, nor does it offer any negative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations include destructiveHint=true, but the description adds valuable behavior beyond that by disclosing that same-named files automatically create new versions. It also clarifies that all files share the same comment and minor_edit settings, which is useful behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise and front-loaded with the primary purpose, followed by the efficiency comparison and key behavioral note. The bulleted use cases add a little length but are relevant and easy to scan.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of a full input schema, an output schema, and annotations, the description covers the essential behavioral and usage context. It doesn't discuss permission requirements or limits, but those are not necessary for a tool of this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't need to add much; it adds only general batch behavior, not parameter-level detail beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: upload multiple attachments to Confluence content in one operation. It explicitly contrasts itself with the sibling tool upload_attachment, making its scope clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context for when to use it: bulk uploading, adding multiple related files, and batch updating attachments. It also names the alternative upload_attachment, though it doesn't explicitly state 'use upload_attachment for a single file'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With only destructiveHint=true available in annotations, the description adds meaningful implementation detail: Server/DC fetches the body and creates the page manually, and attachments are not copied in that path. This tells the agent what to expect beyond the annotation. The description does not contradict the destructiveHint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, first is front-loaded with the core action; the subsequent sentences layer platform caveats without waste. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The main platform-specific behavior and attachment limitation are covered, and the output schema plus 100% parameter documentation handle return values and parameter details. It does not address alternatives or original-page side effects, but those are not required for a correct call.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining why copy_attachments is only supported on Confluence Cloud ('attachments are not copied in the Server/DC path') and that the page body is fetched and recreated, clarifying the mechanism behind destination parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a clear verb-resource statement: 'Copy a Confluence page to a new location.' The word 'copy' plus 'new location' distinguishes it from sibling create/move/delete operations, and later 'new page is created manually' reinforces that the original is being duplicated rather than moved.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides platform context (Cloud native endpoint vs Server/DC manual fetch-and-create) but no explicit when-to-use guidance or alternatives. The intended use is implied by the title and first sentence, but there is no statement distinguishing this from move_page or create_page.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark destructiveHint=true, and the description adds valuable behavioral context by explaining that only the section under the named heading is replaced while macros, layouts, and other sections remain intact. This clarifies the scope of the destructive operation beyond the annotation alone.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, with the core behavior stated in the first sentence. The second sentence adds valuable behavioral detail and rationale without unnecessary repetition or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the high schema coverage, output schema, and destructive annotation, the description is largely complete. It explains what is and is not affected, provides rationale, and the parameter descriptions handle edge cases like case-sensitive heading text and content format. Minor gaps such as duplicate heading behavior are not addressed but are not critical.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already well-documented. The tool description reinforces that only body content is replaced and heading matching is exact, but most parameter-level meaning is appropriately handled by the input schema. This meets the baseline for fully covered schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: 'Update a single section of a Confluence page' and clarifies exactly what is replaced. It clearly distinguishes itself from a full-page update by emphasizing that only the content beneath a named heading changes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly identifies when to use this tool—updating one section without affecting the rest—and contrasts it with the riskier full-page Markdown round-trip workflow. It does not explicitly name the alternative tool, but the usage context is clear from the description and sibling list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral detail: it returns separate restriction lists for read and update operations, and an empty list means unrestricted for that operation. This clarifies the interpretation of results beyond the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and front-loaded with the core purpose, then expands on what is returned and how to interpret empty lists. Every sentence adds useful, non-redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only single-parameter tool with a full output schema, the description is complete. It explains the key behavioral nuance (empty list = unrestricted) and needs no further context for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single parameter page_id, so the schema already documents it fully. The description does not add additional parameter-level detail, but none is needed for this simple, well-covered parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get') with a clear resource ('view and edit restrictions for a Confluence page') and specifies the two operations covered (read/view and update/edit). This clearly distinguishes it from sibling tools like confluence_set_page_restrictions and confluence_get_space_permissions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly indicates this tool is for reading restriction lists, which gives clear context for when to use it. It does not explicitly state when not to use it or name alternatives, but the read-only framing and operation-specific detail make the intended use obvious.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already mark it read-only, and the description adds meaningful behavior beyond that: it returns a flat list with parent_id and depth attributes, emphasizes token-efficient processing, and contrasts with rendering full ASCII trees. This helps the agent know what to expect and why it is preferable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core behavior, then lists return attributes, performance advantage, and a concrete use case. Every sentence earns its place and there is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter read-only tool with an output schema, the description covers the purpose, output shape, token-efficiency rationale, and when to call it. Nothing essential for selecting or invoking the tool is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Both input parameters are already documented in the schema (space_key and limit), so schema description coverage is 100% and the baseline applies. The description mentions depth/title filtering, but those refer to returned attributes rather than input parameters, so it adds no parameter-level meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: get the page hierarchy for a Confluence space as a flat list. The space-wide scope is evident, but it does not explicitly differentiate itself from the closely related sibling confluence_get_page_children, leaving that distinction to inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a clear intended use case: understand space organization before creating or moving pages. It does not state when not to use it or name an alternative tool, so it lacks explicit exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
ReadOnlyHint=true already signals a read operation. The description adds useful behavior beyond that: it names the exact endpoint, discloses the Cloud-only restriction, and describes the returned structure as a results list with principal, operation, and target. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact, front-loaded with the core purpose, and every sentence adds value: endpoint, Cloud caveat, return shape, and intended use. There is no filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With readOnlyHint, full parameter descriptions, an output schema, and a description of the returned permission object shape, the definition is complete for safe and correct invocation. The Cloud-only note prevents a common failure mode.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with space_id explained in detail including how to find it. The description itself adds no parameter-level semantics beyond the schema, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The first sentence states a specific verb and resource: 'List all permission assignments for a Confluence space.' The description also names the wrapped endpoint and the audit use case, making it easy to distinguish from page-level restriction tools like confluence_get_page_restrictions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: use it to audit who has access to a space, and explicitly notes it is only available for Confluence Cloud, warning that Server/Data Center instances use different permission APIs. It does not name sibling alternatives, but the when-to-use and when-not-to-use are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With readOnlyHint=true already present, the description adds meaningful behavioral context by revealing that the implementation differs by platform: CQL on Cloud versus group member API on Server/DC. This is useful for setting expectations about query syntax and the role of group_name, going beyond what the annotation alone provides.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single clear sentence that leads with the action and resource, then adds the key platform-dependent detail in a parenthetical. There is no filler or redundant restatement of the title or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a straightforward read-only user search with three documented parameters, full schema coverage, an output schema, and a readOnly annotation. The description supplies the only missing contextual piece — the platform-specific search mechanism — making the definition complete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters, defaults, and constraints. The tool description itself does not add further parameter details, but the query parameter schema includes CQL examples and quoting guidance. This fits the baseline of 3 where the schema carries the parameter-documentation burden.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Search Confluence users') and distinguishes the resource (users) from other Confluence search tools like confluence_search. It also names the two underlying mechanisms, CQL on Cloud and group member API on Server/DC, which leaves no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when the tool is appropriate: it searches users, not content, and it explicitly adapts behavior based on Cloud vs Server/DC deployment. It does not name alternative sibling tools or state when not to use it, but the user-specific scope is clear enough for an agent to select it correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide destructiveHint=true, and the description adds meaningful behavioral detail: existing attachments with the same filename get a new version, and base64 mode is for servers that cannot read host paths. This goes beyond the annotation without contradicting it. It does not discuss side effects like permission requirements or output details, but the output schema and schema parameter descriptions cover some of that.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized, front-loaded with the core statement, and uses a short list for use cases. It is a bit longer than strictly necessary because some use cases restate the obvious purpose, but the length is justified by the two different upload modes and the versioning behavior.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity, six parameters, and full schema coverage, the description covers the essential decision points: which input form to use, when each is appropriate, and what happens on duplicate filenames. The output schema handles return value clarity. It is complete enough for an agent to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value on top by clarifying the mutually exclusive relationship between file_path and content_base64, explaining when each parameter is required, and describing the practical remote-server scenario for base64 use.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Upload an attachment to Confluence content (page or blog post).' This clearly identifies the action and target, and it is distinct from sibling tools like confluence_upload_attachments by focusing on a single attachment to a single content item.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives strong usage context: it explains the file_path vs content_base64 distinction, says exactly one must be supplied, and advises base64 for remote or containerized servers. It also notes the useful case of updating existing attachments by creating a new version. It does not explicitly call out alternatives like confluence_upload_attachments for batch operations, so it stops short of full alternative routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already include destructiveHint=true, but the description goes further by warning that the action cannot be undone and that all versions of the attachment are permanently removed. This is critical behavioral information for an agent handling a destructive operation and exceeds what the annotation alone conveys.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured, front-loaded with the core purpose and danger, and uses concise bullet lists for use cases and best practices. It is slightly redundant in repeating warnings about permanence, but the repetition serves a safety-critical destructive operation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter destructive tool, the description covers the essential information: what the tool does, the irreversibility, what data is affected, and safety-oriented usage guidance. An output schema exists, so return-value documentation is not required from the description.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the single parameter attachment_id is already well documented in the schema with an example and a warning. The description body adds practical context about verifying the ID via get_attachments, but does not significantly augment the schema's parameter semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb and resource: 'Permanently delete an attachment from Confluence.' It also clarifies the full scope of the deletion—'the attachment and ALL its versions'—which distinguishes this from other deletion or content-modifying tools in the sibling list such as delete_page.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit use cases: removing outdated files, cleaning duplicates, and deleting accidentally uploaded sensitive data. It also gives best practices, including verifying the attachment ID with get_attachments and considering a backup download, though it does not explicitly enumerate when not to use the tool or name a non-deletion alternative in a structured way.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint=true, and the description adds substantial behavioral context: the API's application/octet-stream media type quirk, the reliability of filename filtering, and the returned metadata fields. This goes beyond the annotations and helps agents avoid a common filtering pitfall.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a clear lead sentence, bulleted return details, an highlighted important note, and a useful-for list. It is slightly longer than strictly necessary because the media type caveat is repeated from the schema, but the formatting keeps it scannable and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the output schema exists, parameters are 100% documented, and annotations indicate a read-only operation, the description provides complete context. It explains return fields, the core API behavior caveat, and common use cases, so an agent has everything needed to invoke the tool correctly and interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all parameters are already well documented. The description reinforces the media type caveat and suggests filename as more reliable, adding a small amount of context beyond the schema. However, it doesn't substantially extend parameter semantics for the rest of the parameters, and the wildcard/pattern matching hint conflicts slightly with the schema's exact match statement.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('List all attachments') and resource ('Confluence content item (page or blog post)'), and differentiates from siblings by focusing on metadata listing rather than download or upload operations. This distinguishes it clearly from tools like confluence_download_attachment and confluence_get_page_images.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit use cases ('Discovering what files are attached', 'Getting attachment IDs for download operations', etc.), giving clear context for when to use the tool. However, it does not explicitly name alternative tools or state when not to use this tool in favor of a sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the destructiveHint annotation, the description discloses the critical destructive behavior: it replaces all existing restrictions and can remove all restrictions when parameters are omitted or empty. This gives the agent the key safety-relevant context needed before invoking the tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences with no filler. It front-loads the purpose, then immediately covers the most important behavioral caveat (replacement), and ends with the removal edge case.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The presence of an output schema and destructiveHint covers return values and destructive intent, while the description covers the essential replacement/removal behavior. However, there is slight ambiguity about what happens if only some optional parameters are omitted, so it falls just short of complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full descriptions for all five parameters, so the baseline is 3. The description adds extra value by clarifying the overall replace-all semantics and the special behavior of omitting all parameters or passing empty lists, which is not fully captured by individual parameter descriptions alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Set view and edit restrictions') and the resource ('a Confluence page'), so an agent knows exactly what the tool does. It also differentiates from the sibling confluence_get_page_restrictions by emphasizing the write/set nature.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for modifying restrictions rather than reading them, but it does not explicitly say when to prefer it over alternatives or when not to use it. There is no mention of prerequisites or conditions that would rule it out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description discloses meaningful behavior: the response is a base64-encoded embedded resource, no filesystem access is required, and files over 50 MB will not be downloaded inline and instead yield an error message. This gives the agent a clear expectation of the tool's runtime behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with the core action, followed by essential return-format and size-limit details. Every sentence earns its place, and there is no redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has a single parameter, a simple read-only operation, no output schema, and readOnlyHint=true. The description sufficiently covers the return format, the base64 encoding rationale, and the 50 MB failure behavior, leaving no critical ambiguity for an agent deciding whether and how to call it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides 100% coverage for attachment_id, including an example, how to find IDs via get_attachments, and an example workflow. The tool description itself adds no additional parameter semantics beyond what the schema already documents, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: "Download an attachment from Confluence as an embedded resource." It also distinguishes this tool from sibling list/upload/delete tools by emphasizing the base64-encoded embedded-resource format, making its purpose clear without needing to inspect the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use this tool: when attachment content needs to be available over MCP without server filesystem access. It also states a size limitation (files >50 MB are not downloaded inline), but it does not explicitly name alternatives or say when to prefer sibling tools like confluence_download_content_attachments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true, which already tells the agent this is a safe read operation. The description adds modest behavioral context by mentioning the convert_to_markdown option and its token usage impact, but the core description itself doesn't disclose much beyond what the schema already says. The schema describes the 'raw Confluence storage XHTML' behavior and its token implications, so the description plus schema together provide adequate transparency. Since annotations already cover the safety profile, a 3 is appropriate – the description adds some value but not rich behavioral context beyond what schema/annotations already provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one efficient sentence that conveys the core purpose and the two lookup mechanisms. The schema descriptions are detailed and well-formatted, with examples and clear warnings (e.g., token usage caution for storage format). Every sentence in the schema earns its place – there is no fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description plus 100% schema coverage plus readOnlyHint annotation fully equips an agent to select and invoke this tool correctly. It explains identification methods, precedence, optional behaviors, output format choice, and token usage implications. The output schema exists, so return values need not be described. Nothing an agent needs to call this correctly is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage with detailed explanations for every parameter, including examples for page_id, conditions for space_key, and boolean meanings for include_metadata and convert_to_markdown. The description itself adds the identity-OR-relationship between parameters beyond the individual property descriptions, and clarifies the precedence rule (page_id overrides title/space_key). With full schema coverage, the baseline is 3, but the description's clarification of the mutual exclusivity and precedence adds genuine value, warranting a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Get content') and resource ('a specific Confluence page'), and explicitly names the two lookup paths (by ID, or by title and space key). This clearly distinguishes it from sibling tools like confluence_get_page_children, confluence_get_comments, or confluence_search, which have different focuses.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The schema descriptions clearly state when to use title+space_key vs page_id, note that page_id takes precedence and title/space_key are ignored if page_id is provided, and explain the required relationship. The parameter descriptions effectively serve as usage guidance, telling the agent exactly how to select between alternatives. Additionally, the description's explicit mention of the two identification modes gives clear context for when to invoke this tool versus others like confluence_search or confluence_get_page_children.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint, the description discloses the base64 encoding, the MIME-type whitelist, the filename-extension fallback for ambiguous MIME types, and the 50 MB skip behavior with an error entry in the summary. These are non-obvious behaviors that an agent would not infer from annotations or schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Four short sentences, each carrying distinct operational information; the main action is front-loaded. No redundant restatement of the title or schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one parameter, a readOnly annotation, and no output schema, the description still delivers enough operational detail: output format, filtering rules, fallback behavior, and error handling. A caller can predict what will be returned and what edge cases occur.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema fully covers the only parameter, content_id, with a type, description, and example. The tool description adds nothing beyond that, which is acceptable given 100% schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get'), identifies the exact resource ('all images attached to a Confluence page'), and specifies the output contract (base64-encoded ImageContent). It also states a clear boundary (image-only filtering, non-image attachments excluded) that distinguishes it from general attachment tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use case is clear: retrieve page images for inline rendering. The description implicitly points away from the general attachment tools by stressing that non-image attachments are excluded, though it stops short of naming a sibling like confluence_get_attachments as the alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, and the description adds useful context beyond that: Cloud-only availability and the fact that responses include metadata but not the full body. This gives the agent a clear expectation of the operation's scope without contradicting the annotation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three short sentences with no filler. The purpose is front-loaded, followed by the Cloud restriction, return scope, and a sibling pointer—each sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only list operation with an output schema, two well-documented optional parameters, and a clear sibling pointer, the description covers the essential invocation context. The Cloud-only caveat and metadata-only return behavior are both included, so nothing significant is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both limit and space_key clearly documented in the input schema. The description does not add parameter-specific meaning beyond what the schema provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb-resource pair, 'List Confluence page content templates', and clarifies that it returns metadata (ID, name, description, type) without the body. This distinguishes it from sibling tools like confluence_get_page_template, which fetches a template's full body.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly points to an alternative: 'Use confluence_get_page_template to fetch a template's body.' It also sets a clear prerequisite by noting the operation is only available for Confluence Cloud, so agents know when this tool is applicable and when to route to a sibling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes safety, and the description/schema adds meaningful behavioral detail: simple queries use siteSearch by default with an automatic fallback to text search, and special CQL identifiers require quoting. This helps the agent predict how queries will be interpreted.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The top-level description is a single front-loaded sentence. The extensive CQL examples are placed in the schema where they belong and each example earns its place by demonstrating distinct, non-obvious syntax. Nothing is redundant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a search tool with annotations, a complete input schema, and an output schema, the description plus parameter documentation covers query modes, limits, filtering, quoting caveats, and common use cases. An agent has enough context to invoke the tool correctly without further inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, and the query parameter description goes far beyond a label by providing multiple CQL examples, quoting rules, and common search patterns. The spaces_filter parameter also explains its interaction with the CONFLUENCE_SPACES_FILTER environment variable and how to disable filtering.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Search') and resource ('Confluence content'), and clarifies the query styles ('simple terms or CQL'). This clearly separates it from sibling 'confluence_search_user', which targets users rather than content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the general usage context clear and the schema provides extensive CQL guidance, but it does not explicitly explain when to prefer this tool over alternatives such as confluence_search_user. Usage is implied rather than directly contrasted with sibling search tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![AtlMCPforDC MCP server](https://glama.ai/mcp/servers/Nikel-san/AtlMCPforDC/badges/card.svg)](https://glama.ai/mcp/servers/Nikel-san/AtlMCPforDC)

Score Badge

Copy to your README.md:

[![AtlMCPforDC MCP server](https://glama.ai/mcp/servers/Nikel-san/AtlMCPforDC/badges/score.svg)](https://glama.ai/mcp/servers/Nikel-san/AtlMCPforDC)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Nikel-san/AtlMCPforDC'

If you have feedback or need assistance with the MCP directory API, please join our Discord server