RibbonSmith

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool targets a distinct aspect of the ribbon editing workflow: status, checkout, inspection, editing actions, validation, publishing, and backup/restore. Even the get_* tools return different data (structure, command, diff), leaving no ambiguity about which tool to call.
Naming Consistency5/5
All tools share the 'ribbon_' prefix and use snake_case with a verb_noun structure (get_structure, add_button, restore_backup). Single-word verbs like status, checkout, and publish are also clear and consistent with the overall pattern, with no mixed conventions.
Tool Count4/5
With 16 tools, the set is slightly above the typical 3-15 range, but each tool maps to a distinct step in the ribbon lifecycle (checkout, edit, validate, publish, backup). The count is justified by the complexity of Dataverse ribbon customization and no tool feels redundant.
Completeness5/5
The tool set provides full lifecycle coverage: start (status, checkout), inspect (get_*), modify (add, hide, customize, edit, remove), validate (preview_diff), publish (publish, publish_status), and revert (backups, restore). The escape hatch 'ribbon_edit_diff' covers any edge cases, leaving no obvious dead ends.
Average 4.2/5 across 16 of 16 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- Last stable release on July 6, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses an important boundary: 'Does not touch the environment,' indicating the operation is local-only. However, it does not mention whether the action is reversible, whether backups are created, or any permission requirements. It adds some transparency but lacks depth for a destructive 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 two sentences with no filler: it immediately states the primary action and then adds a key safety clarification. Every word earns its place, making it appropriately sized and front-loaded.
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 simple tool with full schema coverage and no output schema, the description is reasonably complete. It explains the core operation and clarifies that the environment is untouched. However, given the destructive nature and the large set of sibling tools, it could benefit from stating what happens to checked-out status or how it relates to backups. Still, it is adequate for the tool's simplicity.
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 provides 100% coverage with descriptions for both parameters (entity and environment), including an experimental note for APPLICATION. The tool description itself adds no parameter-specific meaning, so the baseline of 3 applies, as the schema already does the heavy lifting.
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: 'Reset the working copy to the last exported/published state.' It also clarifies scope with 'Does not touch the environment,' which distinguishes it from sibling tools like publish or restore_backup that affect the environment.
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 is implied: this tool should be used when the user wants to discard local changes and revert to the last exported/published state. However, it does not explicitly state when not to use it, nor does it reference alternatives like ribbon_restore_backup for undoing published changes. The guidance is minimal but not misleading.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses a meaningful nuance: core rule definitions (Mscrm.*) remain as ID references while non-core rule bodies are copied, and it implies a possible pinning use case. However, it omits important behavioral details for a mutation tool: whether a checkout is required (ribbon_checkout exists as a sibling), whether existing customizations in the working diff are overwritten, and what happens to the working diff state. This leaves gaps in the agent's understanding of side effects.
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 sentences, front-loaded with the primary action and purpose. The second sentence adds an important behavioral detail, and the third sentence guides the next steps. Every sentence earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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 (3 params, no output schema, no annotations), the description is fairly complete. It explains the tool's purpose, a key behavioral nuance (core vs non-core rules), and the return value ('returned XML') plus follow-up actions. However, it does not mention prerequisites like checkout or whether it overwrites existing working-diff entries, which are important for safe usage. The sibling list provides some context but does not substitute for explicit guidance.
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 baseline is 3. The description does not add extra parameter-level meaning beyond what the schema already provides; it only contextualizes the overall operation. It mentions the returned XML but not how the parameters relate to it. Thus, no additional semantics are contributed.
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 tool's function with a specific verb ('Copy') and resource ('an out-of-the-box command definition from the composed ribbon into the working diff'). It also names the equivalent Ribbon Workbench operation, which helps the agent map this to a known concept. It distinguishes itself from sibling tools like ribbon_get_command (which presumably reads without copying) and ribbon_add_button (which creates new commands).
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 for when to use the tool: when an existing out-of-the-box command needs to be customized. It also gives workflow guidance by mentioning subsequent steps ('edit the returned XML with ribbon_edit_diff, or publish as-is to pin the current behavior'). However, it does not explicitly state when not to use it or compare to alternative tools such as ribbon_add_button for new commands, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It states the tool returns the full definition including rule bodies, but it does not explicitly mention read-only behavior, side effects, permissions, or the experimental nature of APPLICATION support, which is only noted in the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences that front-load the main function and then give usage context. Every word earns its place; there is no redundancy or 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 description provides both the tool's primary function and its intended usage context. It gives a good sense of the return content (actions, enable rules, display rules with bodies) but lacks output structure details and the experimental warning for APPLICATION support, which is a minor gap.
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 each parameter already has a detailed description. The tool description adds no additional parameter semantics beyond what the schema provides, which is the baseline for this dimension.
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 tool returns the full definition of a command, listing its actions and rules, which distinguishes it from sibling tools like ribbon_get_structure or ribbon_get_diff. The verb 'Return' and the resource 'command definition' make the purpose specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use this before customizing or reusing an out-of-the-box command,' providing a clear, actionable context for when to invoke the tool. It does not explicitly exclude alternatives or mention siblings, but the context is strong enough to guide an agent.
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?
With no annotations, the description carries the transparency burden. It discloses the return format (compact JSON tree) and the concept of being the ground truth, which is helpful. Yet it does not mention caching behavior (e.g., refresh parameter bypasses cache), potential errors, or explicitly state that the operation is read-only, leaving some behavioral aspects implicit.
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 two sentences: the first defines the output and contents, the second explains utility and filtering. Every phrase earns its place with no redundancy or filler, and the key details are front-loaded.
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 description covers the output structure, intended use cases, and filtering options, which is sufficient for an agent to invoke the tool correctly. The schema provides detailed parameter semantics, including the experimental APPLICATION note. While no output schema exists, the description adequately characterizes the response shape; a minor gap is the lack of explicit mention of caching or error behavior, but this is not critical for a simple getter.
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 all parameters already have descriptions. The main description reinforces filtering by location and tab/group id, but adds no new semantic details beyond the schema. Given the baseline of 3 for full schema coverage, no further credit is warranted.
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 the specific verb 'Return' and the resource 'fully composed ribbon', then details the contents (tabs, groups, controls) and the output format (compact JSON tree). This clearly distinguishes it from sibling getters like ribbon_get_command, which targets a single command rather than the full structure.
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 explains the tool's utility as the ground truth for valid Location values, ids to hide, commands to reuse, and sequence placement, indicating it should be used before ribbon modifications. It also gives practical advice to filter by location and tab/group id to keep output small. However, it does not explicitly compare against alternative getters like ribbon_get_diff or ribbon_get_command, so prohibitions are absent.
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?
No annotations, so the description must carry safety and side-effect information. It discloses that the removal occurs in the local working copy, that it removes the node others may target, and that APPLICATION support is experimental (in schema). It does not mention reversibility, publish requirement, or permissions, leaving some ambiguity for a destructive action.
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, front-loaded with the action and mechanism. The caveat about display rules earns its place, with no redundant 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?
For a mutation tool with no annotations, the description covers what, how, where (local working copy), and source of input. It omits explicit next steps like publish or discard, but the sibling ribbon_publish/ribbon_discard and 'local working copy' phrasing partially cover that context.
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%; every parameter (entity, controlId, environment) has a description. The description adds the useful pointer that controlId comes from ribbon_get_structure, but otherwise relies on the schema. Baseline 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?
Description uses specific verb 'Remove' with resource 'control from the ribbon' and mechanism 'HideCustomAction'. It distinguishes from siblings by targeting usually out-of-the-box controls and sourcing ids from ribbon_get_structure.
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 clear context: hide via HideCustomAction; explicitly cautions that for commands you own, an always-false display rule is often preferable, creating an exclusion. It stops short of naming sibling tools like ribbon_customize_command, but the guidance is actionable.
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?
With no annotations provided, the description must disclose behavioral traits itself. It adds context about backup timing and restore compatibility, but does not explicitly state that this is a non-destructive read operation or describe what happens when no backups exist. The verb 'List' implies read-only, but the description could be more explicit.
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 starts with the action, and includes relevant context (backup timing and restore linkage) without waste. Every clause adds value.
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 this is a simple list operation with no required parameters, no output schema, and a clearly stated purpose, the description covers the essential information. The tie to ribbon_restore_backup makes the tool's role in the workflow clear. Minor omission: no description of the response format, but that's acceptable given the tool name.
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 fully describes both parameters ('Filter by entity' and environment with env var fallback), so the description need not repeat them. It adds no parameter-specific semantics beyond the schema, so a 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 'List backup zips' – a specific verb and resource – and clarifies the backups are 'taken at checkout and before every publish,' making it distinct from sibling tools like ribbon_get_structure or ribbon_checkout. The connection to ribbon_restore_backup further solidifies its purpose.
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?
It explains the backups are those 'that ribbon_restore_backup can re-import,' linking directly to a sibling tool and signaling this list is a prerequisite for restore operations. It also states when backups are created, giving context for when to use this tool. It does not explicitly state exclusions, but the linkage provides clear usage 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'Show' implies a read-only operation, and it lists informational categories, but it does not explicitly state that no changes are made or address permission requirements. The description adds some transparency by naming WhoAmI, dirty state, and backups, but it could be more explicit about absence of side effects.
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 succinct, two sentences long, with the action leading. The first sentence lists the key data points, and the second provides a clear usage directive. No filler or redundant information.
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?
Without an output schema, the description appropriately summarizes the returned content (connection, checkouts, backups) at a high level. It does not detail the exact response structure, but for a status overview tool, this is sufficient for an agent to know what to expect. The inclusion of 'recent backups' and 'dirty state' gives helpful context for interpreting the tool's output.
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% coverage of the single optional parameter 'environment', including its format and fallback to an environment variable. The description adds no additional parameter semantics beyond what is already in the schema, so the baseline score 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 clearly states the tool's function with a specific verb ('Show') and resource (connection, checkouts, backups for Dataverse). It differentiates from siblings like ribbon_list_backups and ribbon_checkout by aggregating multiple status types into a single overview. The phrase 'Start here to orient yourself' reinforces its role as an entry point.
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 usage context by saying 'Start here to orient yourself', implying this is the first tool to invoke when checking workspace state. However, it does not explicitly mention alternatives or when not to use this tool, such as deferring to ribbon_list_backups for detailed backup history or ribbon_checkout for specific checkout details.
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 no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool returns the un-published working copy and explicitly mentions the checkout requirement — a meaningful condition. The verb 'Return' implies a read operation, but the description does not touch on error cases (e.g., no checkout) or return representation, which keeps it from a perfect score.
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, focused sentence that opens with the action and object, then adds the critical detail about checkout. Every clause earns its place — 'current working copy', 'requires checkout', and 'complete declarative customization state' all add unique value without redundancy.
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 getter with two well-documented parameters and no output schema, this description adequately conveys the return value's nature and a key precondition. It could mention the expected return format or behavior when checkout is missing, but the name, title, and description together give an agent enough to invoke and interpret this tool 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 input schema provides 100% coverage of both parameters, including detailed descriptions (e.g., the 'APPLICATION' experimental note and the environment default). The description adds no parameter-specific meaning beyond what the schema already contains, so it meets the baseline for well-covered schemas rather than exceeding it.
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 ('Return') and names a concrete resource ('the entity's RibbonDiffXml'), further narrowing it to the 'current working copy' — the full declarative customization state. This clearly distinguishes it from sibling getters like ribbon_get_structure and ribbon_get_command, which target more focused pieces. The phrase 'complete declarative customization state that will be published' removes any ambiguity about scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states a clear prerequisite: 'requires checkout', telling the agent this tool is only usable when an active checkout exists. It also frames the return as the full working state, implicitly steering away from the more partial getters. However, it does not explicitly name alternatives or state when not to use it, leaving the differentiation from sibling getters somewhat implicit.
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 no annotations provided, the description carries the full burden for behavioral disclosure. It explicitly states 'without touching the environment,' which is a critical safety guarantee, and enumerates the validation checks performed (schema order, id uniqueness, refs, location, web resource existence). This exceeds minimal transparency, though it omits details like behavior when no pending changes exist.
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 two sentences: the first delivers the action, content, validation scope, and non-mutating nature; the second gives an imperative usage directive. No words are wasted, and the most important information ('without touching the environment' and 'Always call before ribbon_publish') is prominent.
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 no output schema and no annotations, the description effectively covers what the tool returns (working XML + validation report), the scope of validation, the safety profile, and the intended call timing. It could add edge-case behavior (e.g., no pending changes) but is sufficiently complete for a dry-run validation tool among many ribbon 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?
The input schema provides 100% description coverage for both parameters, including the entity logical name and the optional environment URL with clear examples. The tool description adds no additional parameter-level detail, but the schema's documentation is sufficiently complete that 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 uses a specific verb ('Show') and names the exact resource ('working RibbonDiffXml alongside the full validation report'), listing the validation categories. It also distinguishes from sibling tools by noting it runs 'without touching the environment,' positioning it as a non-mutating preview rather than an edit or publish tool.
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 explicit instruction 'Always call before ribbon_publish' clearly states when to use this tool, giving a strong usage signal. It does not mention when not to use it or name alternative tools for specific scenarios, but the placement relative to the publish workflow is unambiguous.
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 no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that the tool polls an async operation, then completes it by publishing, verifying live, and syncing local state. It also notes the expected duration and the need for repeated calls, which helps the agent understand the polling behavior. However, it does not mention error handling or what happens if the import fails.
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 concise sentences, front-loaded with the main purpose, then elaborates on the completion behavior and provides usage guidance. Every sentence contributes value with no redundancy.
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 two-parameter schema and lack of output schema, the description covers essential contextual information: what operation it completes, how long it takes, and the success statuses. It also implies the need for entity context. It does not cover failure modes or what happens if the import never completes, leaving a minor gap.
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 both parameters, including the experimental note for APPLICATION and the environment variable fallback. The tool description itself adds no extra parameter semantics, so 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 clearly states the tool's purpose: 'Poll the async solution import started by ribbon_publish or ribbon_restore_backup' and 'completes the operation: publishes the ribbon, verifies it live, and syncs local state.' This distinguishes it from sibling tools like ribbon_publish and ribbon_restore_backup, which initiate operations, and ribbon_status, which only checks status without completing.
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 usage context by referencing the initiating tools ('started by ribbon_publish or ribbon_restore_backup') and provides explicit directive to 'Call repeatedly (imports typically take 1-3 minutes) until status is 'published'/'restored'.' This tells the agent when and how to use the tool, though it doesn't explicitly say when not to use it.
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?
Discloses that the server generates schema-correct XML with id conventions and prefixes, and that the operation targets the local working copy, implying a checkout/publish workflow. No annotations exist, so this context is valuable, though it omits error behavior and mutability details.
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 dense sentences: purpose, server behavior, prerequisites/location. No 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?
Covers the essential workflow (checkout, get location, add) and server-side XML generation, making it understandable for an agent. Missing return value and formal alternative guidance, but given rich schema, it is reasonably 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?
Schema covers 76% of parameters; description adds the crucial guidance that location comes from ribbon_get_structure as a group id + '.Controls._children', and clarifies label/webresource prefixing. This compensates for the most complex parameter without duplicating 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?
Clearly states it adds a button with command/rules/labels declaratively, and distinguishes from sibling tools by focusing on adding vs customizing/hiding. The phrase 'one declarative call' clarifies the abstraction level.
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?
Mentions prerequisite 'Requires ribbon_checkout first' and instructs to get location from ribbon_get_structure, giving clear context for when to invoke. However, it does not explicitly name alternatives or conditions where another sibling tool (e.g., ribbon_customize_command) should be used.
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 no annotations provided, the description carries the full burden. It convincingly discloses key behaviors: XML parsing, normalization to schema element order, validation, and that errors are returned without saving unless 'force' is set. It also hints at the destructive nature by saying 'replace the entire working RibbonDiffXml.' It does not mention permissions or reversibility, but the detail provided is strong.
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 sentences, front-loaded with the primary purpose, and every sentence adds value: what it does, how it behaves, and a required precondition. No filler 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?
Given the tool's complexity (replacement, validation, force flag), the description covers the most important aspects: purpose, behavior, and a prerequisite. It does not explicitly state what happens on successful save (only errors are mentioned), nor does it mention potential need for checkout, but the overall guidance is sufficient for making an informed call.
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 baseline is 3. The description adds some context around the 'force' behavior and the need to provide a complete XML, but these are already implied by the schema ('Save even with validation errors', 'Complete <RibbonDiffXml>'). The description does not significantly extend parameter meaning 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?
The description clearly states the tool's purpose: 'replace the entire working RibbonDiffXml with the supplied XML.' It uses a specific verb ('replace') and resource ('RibbonDiffXml'), and distinguishes itself from siblings by framing it as an 'escape hatch for anything the declarative tools don't cover.'
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 indicates when to use this tool: when declarative tools don't cover something (flyouts, menus, groups, tabs, command edits). It also provides a clear prerequisite: 'Read the current state first with ribbon_get_diff,' guiding the agent on the correct workflow.
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 no annotations provided, the description carries the burden of behavioral disclosure. It states that removal happens in the 'local working copy' and that the change 'un-hides / un-customizes after the next publish,' which implies a deferred, reversible-ish operation. It lacks explicit statements about permissions, restore options, or error behavior, but the given context is more than minimal.
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 two sentences, front-loaded with the action and target, and every clause carries meaning. There is no filler or repetition of schema details, making it both concise and well-structured.
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 mutation tool with no output schema and no annotations, the description adequately covers the operation's scope (what elements, where, when), the prerequisite id discovery, and the deferred publish effect. It does not mention error handling or specific edge cases, but for this complexity level, the context is reasonably 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 covers all parameters with descriptions (100% coverage), so the baseline is 3. The description adds value by linking the 'id' parameter to the workflow ('by its Id' and 'Use ribbon_get_diff to list current ids'), which helps the agent understand how to obtain valid values.
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 tool's purpose: removing specific ribbon customization elements (CustomAction, HideCustomAction, CommandDefinition, rule, LocLabel) from the local working copy by Id. It distinguishes itself from sibling tools like ribbon_edit_diff and ribbon_discard by naming the exact element types and the 'working diff' context.
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 explicit guidance on a prerequisite: 'Use ribbon_get_diff to list current ids.' It also clarifies when the effect takes place ('after the next publish'). However, it does not mention alternative tools or explicit when-not-to-use conditions, so it stops short of a full 5.
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 no annotations, the description carries the full burden and does well by disclosing side effects: re-import, publish, reset local working copy, and async execution with waitSeconds. It does not cover permissions or error conditions, but the core behavioral traits are transparent.
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?
Two sentences, front-loaded with the main action, and every sentence adds value. It avoids redundancy and clearly communicates the workflow and async caveat in a compact format.
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 tool with no output schema and no annotations, the description sufficiently covers purpose, workflow, side effects, and async follow-up. It could mention prerequisites or failure modes, but the core operational context is complete 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.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 67%, and the description adds meaning beyond the schema by explaining waitSeconds semantics ('if it outlasts waitSeconds, finish with ribbon_publish_status') and implying backupId source via 'backup solution zip' plus the schema's description. The description enhances understanding of the async timeout behavior.
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+resource: 'Re-import a backup solution zip (restoring the entity's RibbonDiffXml to that point in time), publish, and reset the local working copy to match.' It clearly identifies this as 'the revert mechanism' and distinguishes it from sibling tools like ribbon_publish by focusing on backup restoration.
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 that this is the revert mechanism and explicitly mentions the async behavior with a reference to ribbon_publish_status as a follow-up. However, it does not explicitly state when NOT to use this tool or compare it to other restore/undo alternatives.
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?
With no annotations, the description fully discloses side effects: creates/reuses a temporary unmanaged solution, exports it, stores a restorable backup, and initializes a local copy. It also explicitly states that nothing changes in the environment until ribbon_publish, providing critical behavioral context beyond just 'checkout'.
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?
Two sentences, efficiently front-loaded with purpose and followed by a concise process explanation. Every sentence adds value, and the description avoids redundant or verbose language.
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 complex tool with multiple side effects, the description is complete: it covers the workflow (temporary solution, export, backup, local copy), the scope (entity or application), and the critical constraint that changes only materialize on ribbon_publish. It enables an agent to understand when and how to use the tool within the broader ribbon workflow.
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 has 100% parameter description coverage, including details about the 'entity' (logical name or 'APPLICATION') and 'environment' (URL, optional). The description does not add additional parameter-specific meaning, so it meets the baseline without exceeding it.
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?
Description clearly states the tool's purpose: 'Begin editing the ribbon of an entity (or the application ribbon).' It uses a specific verb ('checkout'/'begin editing') and resource (ribbon), and distinguishes itself from siblings like ribbon_publish and ribbon_discard by detailing the checkout process that initializes a local working copy.
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 workflow context: 'All edit tools operate on this local copy; nothing changes in the environment until ribbon_publish.' This tells an agent to use checkout before any edit tool and to publish later. However, it does not explicitly name alternatives or exclusions, such as using ribbon_get_structure for read-only inspection.
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?
With no annotations, the description carries the full burden of behavioral disclosure. It thoroughly explains the side effects: it backs up current server state, performs an async import, publishes via PublishXml, and verifies by re-reading. It also discloses timeout behavior ('returns status 'importing'') and what is returned (backup id). This is rich, honest, and goes well beyond basic 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 structured as a concise, linear sequence of steps, packed with essential information about the publishing pipeline, timeout handling, and return values. Every sentence and clause earns its place, with no fluff or repetition. It is front-loaded with the primary action ('Validate, back up, then write').
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 complex (multi-step, async, mutating), yet the description explains the full workflow, return status, backup id, and how to handle timeouts. Since there is no output schema, the description adequately covers return values and follow-up behavior. It is complete for an agent to decide when to use it and what to expect.
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 of all three parameters with detailed descriptions. The tool description adds marginal value by referencing waitSeconds in the workflow ('wait up to waitSeconds') and mentioning entity specifics implicitly, but it does not offer significant new semantic meaning beyond the schema. Baseline 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 tool's purpose: to publish the working RibbonDiffXml to the environment, with a specific process (validate, backup, import, publish, verify). It distinguishes itself from sibling tools like ribbon_publish_status (explicitly mentioned as a follow-up for long imports) and ribbon_restore_backup (via the returned backup id).
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?
It provides clear context on when to use this tool (when you have a working diff to publish) and explicitly directs to ribbon_publish_status if the import outlasts the wait. However, it does not enumerate exclusions or alternative tools beyond that, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

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:

[![ribbonsmith MCP server](https://glama.ai/mcp/servers/Longman006/ribbonsmith/badges/card.svg)](https://glama.ai/mcp/servers/Longman006/ribbonsmith)

Score Badge

Copy to your README.md:

[![ribbonsmith MCP server](https://glama.ai/mcp/servers/Longman006/ribbonsmith/badges/score.svg)](https://glama.ai/mcp/servers/Longman006/ribbonsmith)

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/Longman006/ribbonsmith'

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