Colba MCP Server

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
Most tools target distinct resource-action pairs (e.g., list_pipelines, list_blueprints, list_processes), but some overlap exists between approval tools (submit_decision vs resolve_mcp_approval) and template creation (create_pipeline vs instantiate_blueprint). The descriptions are detailed enough to differentiate them with careful reading.
Naming Consistency5/5
All tools follow a consistent verb_noun pattern in snake_case (e.g., list_pipelines, create_workgroup, submit_decision). Minor deviations like resolve_mcp_approval and get_update_log are still predictable and stylistically consistent.
Tool Count3/5
With 28 tools, the server is on the heavier side, but the broad enterprise workflow domain (pipelines, processes, approvals, org structure, custom fields, vendors) justifies the count. The scope is not single-purpose, so the number feels appropriate though slightly over the typical comfort zone.
Completeness4/5
The server covers core lifecycle operations for pipelines, custom fields, and processes, with adequate approval and org tools. Minor gaps exist (e.g., no vendor update, no workgroup update, no process cancellation), but these do not create dead ends for common workflows.
Average 4/5 across 28 of 28 tools scored. Lowest: 2.9/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 12 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
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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?
With no annotations, the description carries the full burden for behavioral disclosure. It only states the creation action without addressing permissions, duplicate handling, required fields beyond name, mutability, or response format. This is a clear gap for a mutation tool.
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 compact and front-loaded with the primary purpose. The parameter lines are brief and free of fluff, making the structured list easy to scan. However, the formatting could be slightly improved by grouping or marking required fields.
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?
Given 10 parameters, no annotations, no output schema, and no usage guidance, the description is insufficient for correct invocation. Half the parameters are undocumented and there is no explanation of the creation process, restrictions, or results, leaving critical context gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains 5 of the 10 parameters (name, email, account_number, bank_country_code, financial_details). However, it completely ignores visible, settings, is_active, address_details, and contact_details, and the schema provides no descriptions at all. It adds some value but fails to compensate for the 0% 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 begins with 'Create a new supplier/vendor profile,' which is a specific verb and resource. It clearly distinguishes this from sibling tools like list_vendors and delete_vendor.
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 on when to use this tool versus alternatives, no prerequisites, and no mention of related operations. The intended use is only implied by the verb 'Create,' so the agent lacks clear decision support.
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?
No annotations are provided, so the description must carry the behavioral disclosure burden. 'Sync' implies a mutation that could overwrite or delete existing members, but the description doesn't explain whether it replaces the full directory, merges, or handles deletions. It also doesn't mention permissions, reversibility, or return behavior.
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 two short sentences with the purpose first and the parameter hint second. It is efficient with no fluff, though the brevity sacrifices critical operational details.
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?
For a sync operation, the description is incomplete. It lacks critical context such as whether existing members not in the provided list are removed, whether the operation is atomic, and what happens on failure. The lack of an output schema and any behavioral disclosure makes this insufficient for an agent to predict outcomes.
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 zero description coverage for the only parameter 'data'. The description adds 'List of members mapping to the onboarding structure', giving some meaning about the expected content, but it doesn't specify the exact shape or fields of the onboarding structure. This partially compensates for the schema gap but remains vague.
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 'Sync members of the organization', providing a specific verb (sync) and resource (members). It distinguishes from siblings like list_members by implying a write/update operation, but it doesn't explicitly contrast with other member-related tools.
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 on when to use this tool versus alternatives such as list_members or create_vendor. The description does not state prerequisites, exclusions, or scenarios where syncing is appropriate.
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?
No annotations are provided, so the description is the sole source of behavioral disclosure. It does not disclose that deletion is likely irreversible, nor any side effects, permissions, or soft-delete behavior, which is a significant gap for a destructive mutation.
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 extremely concise, with two short sentences and no unnecessary words. All information is front-loaded in the first sentence.
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 one parameter and no output schema, the description covers the basic action but omits important contextual details like irreversibility, relationship to accounting records, and return behavior. The absence of annotations further increases the burden, leaving the description incomplete.
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 description adds that vendor_id is a UUID, which supplements the schema's generic 'string' type. However, it only restates the parameter name and provides no additional semantic context, such as where to find the UUID or whether it references an external system.
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 ('Delete') and resource ('vendor from accounting records'), clearly distinguishing it from sibling tools like create_vendor or list_vendors. It directly states the tool's function.
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?
There is no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only states the action without context on deletion workflows or related tools.
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?
There are no annotations, so the description must carry the full burden of behavioral disclosure. It only lists parameters and their meanings but does not mention any side effects, permission requirements, reversibility, or impact on existing data. For a mutation tool, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured as a single sentence followed by a bullet list of parameters. It is reasonably concise and front-loaded with the main purpose, though some redundancy occurs with the repeated 'Optional' prefix.
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 no output schema and no annotations, the description should explain the tool's behavior more thoroughly, including what happens on success, whether changes are reversible, and any dependencies. The current text only states the action and parameter meanings, leaving the operation's context incomplete.
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 0% description coverage, but the description provides brief one-line meanings for all 8 parameters, such as 'name: Optional system name' and 'validation: Optional validation schema.' This compensates for the lack of schema descriptions, though the explanations are shallow and do not give detailed constraints or 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 function: 'Update an existing custom field / global field registration.' This is a specific verb and resource, and it distinguishes from sibling tools like create_custom_field and delete_custom_field.
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 tool is for existing fields, but it does not provide explicit guidance on when to use it vs. alternatives, nor does it mention exclusions or prerequisites. Sibling tool names are not referenced in the description.
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?
With no annotations, the description carries the full burden of disclosing behavioral traits. It says 'Delete' but does not mention that deletion is permanent, irreversible, or might fail if the field is in use. There is no mention of cascading effects or permissions required, which is critical 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 consists of two short sentences: the first states the action, and the second explains the parameter. It is front-loaded and concise, with no redundant wording or filler. Every word contributes meaning.
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 one-parameter delete tool with no output schema, the description covers the basic operation and parameter semantics. However, it lacks the side-effect disclosure and usage context that would make it fully complete, especially since deletion is irreversible. The description is adequate but leaves important operational details undisclosed.
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 description adds semantic meaning beyond the schema by identifying field_id as a 'UUID of the custom field to delete.' This clarifies the expected format and role, which the schema alone (just type string) does not provide. Given the very low schema coverage, this compensation is valuable.
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 ('Delete') and the resource ('a custom field'), and it is distinct from sibling tools like create_custom_field, update_custom_field, and list_custom_fields. Even though the sibling list is not explicitly referenced, the verb+resource pairing makes the 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 Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives, such as update_custom_field or delete_vendor. There are no prerequisites, limitations, or contextual hints. For a deletion tool, one would expect at least a note that it is for removing an existing field rather than toggling or archiving.
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?
No annotations are provided, so the description must disclose behavioral traits. It fails to explain whether the update is partial or full, what happens if the template_id does not exist, any permission requirements, or what the return value is. This is a significant gap for a mutation tool.
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 directly lists the parameters in a clear format. It wastes no words, though it could be slightly more structured by separating the main purpose sentence from the parameter list, but this is efficient.
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 no output schema and no annotations, the description leaves out critical context: update semantics (partial vs full replacement), error handling, and return behavior. For a tool with 4 parameters, more guidance is needed to use 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 0%, so the description must compensate. It provides basic meaning for each parameter (e.g., template_id is UUID, pipeline_config is JSON config, name/description are optional). However, it does not explain how pipeline_config is merged or any constraints beyond 'optional'. It adds some value but not enough to fully offset the schema gap.
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 verb 'Update' and the resource 'existing workflow pipeline template', which distinguishes it from create_pipeline (create) and archive_pipeline (archive). The scope is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies use for updating an existing pipeline template, which contrasts with creating or archiving. However, it does not explicitly state when not to use it (e.g., for new templates use create_pipeline), so no strong exclusions are provided.
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?
No annotations are provided, so the description carries the full burden. It only states 'Create' and lists parameters; it does not disclose return value, permissions, side effects, idempotency, or reversibility. For a mutation tool, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: one clear purpose line followed by a compact bullet-like list of parameters. Every line adds value and there is no 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?
Given no annotations or output schema, the description covers the essential aspects: clear purpose, all parameters explained, and workflow context. It could mention return behavior or that update_custom_field exists for modifications, but the description is sufficient for a straightforward create operation.
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?
The input schema has zero descriptions, but the description fully compensates by explaining all 7 parameters, including naming format (alphanumeric/snake_case), purpose of each, optionality, and specific context (e.g., 'options' for select fields, 'validation' as regex/constraint dictionary). This adds rich meaning beyond the raw 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 'Create a custom metadata field for workflows' – a specific verb and resource. It distinguishes from siblings like delete_custom_field, list_custom_fields, and update_custom_field by its 'create' 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?
No guidance on when to use this tool versus alternatives. It does not mention that update_custom_field is for modifying existing fields or that list_custom_fields shows current fields. The description implies usage through its parameter list but provides no explicit context.
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?
No annotations are provided, so the description carries the full burden. It states the deletion action but does not disclose side effects, irreversibility, cascading removals, or permission requirements—critical 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 exceptionally concise—two short sentences, front-loaded with the verb and resource. Every sentence contributes essential information with no padding or repetition.
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 one-parameter delete tool, the description covers the core intent and parameter. However, since no output schema or annotations exist, it omits important behavioral details such as success/failure responses and side effects, making it adequate but not 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?
With 0% schema description coverage, the description compensates by explaining workgroup_id as 'UUID of the workgroup to delete.' This adds meaningful semantic context beyond the schema's plain string type and is sufficient for the single 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?
Description uses the specific verb 'Delete' and clearly identifies the resource, 'a workgroup from the organization structure.' This distinguishes it from sibling tools like create_workgroup and list_workgroups, so the 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The tool is self-explanatory enough to infer when to use it, but the description provides no explicit guidance on when not to use it, prerequisites, or alternatives. Usage is implied rather than clearly stated.
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?
No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states 'deactivate/archive' without detailing reversibility, effects on running processes, required permissions, or return values. This is minimal behavior information.
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 states the action, the second provides parameter guidance. Every word earns its place, with no redundancy and clear front-loading of purpose.
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?
With one parameter, no output schema, and no annotations, the description covers the purpose and parameter source adequately. However, it omits behavior after archiving (e.g., whether it is reversible, if any confirmation/errors are returned), leaving the agent with some uncertainty about the tool's full effect.
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 coverage is 0%, and the description fully compensates by explaining that template_id must be the 'id' field from list_pipelines, explicitly warning against using 'pipeline_id'. This adds critical semantic meaning beyond the bare 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?
The description clearly states the action ('Deactivate/archive') and the resource ('a workflow pipeline template'). It is specific enough to distinguish itself from sibling tools like create_pipeline or update_pipeline, though it doesn't explicitly compare to alternatives.
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 a crucial usage lesson: 'MUST use the 'id' field from list_pipelines, NOT 'pipeline_id''. This guides the agent on the correct prerequisite source for the parameter, giving clear context for invocation. However, it doesn't discuss when to avoid this tool or alternatives.
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 does disclose the return content ('Complete blueprint details including its pipeline_config baseline'), which goes beyond a simple 'get' statement. However, it doesn't mention error behavior, authorization needs, or explicitly confirm read-only semantics beyond the verb 'Retrieve.'
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: the first sentence states the action, the second defines the parameter, and the third summarizes the return. Every sentence earns its place with no 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?
For a single-parameter read tool with no annotations or output schema, the description covers the essential aspects: purpose, parameter meaning, and return value. It even adds detail about the pipeline_config baseline. It falls short of perfect by not explaining behavior for non-existent IDs or access restrictions, but given the simplicity, this is adequate.
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 schema only defines blueprint_id as a string with title 'Blueprint Id,' but the description adds 'blueprint_id: UUID of the blueprint,' clarifying the expected format and purpose. Since schema description coverage is 0%, this compensates well, though it could specify format constraints in more detail.
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: 'Retrieve the full configuration of a specific pipeline blueprint.' It clearly distinguishes this from sibling tools like list_blueprints (list all) and instantiate_blueprint (create instance), indicating a targeted retrieval 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 provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, exclusions, or comparisons to list_blueprints or other siblings. The usage is only implied by the word 'specific,' which is weak.
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?
No annotations are provided, so the description carries the full burden. It lacks disclosure about return values, permissions, idempotency, or side effects. It only documents parameters, not behavioral traits of the 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 concise and well-structured: a lead sentence stating the purpose followed by a compact parameter list. Every line is informative and there is no redundant wording. It is front-loaded with the primary action.
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 create tool with 4 parameters and no output schema, the description covers all parameters and the core action. However, it fails to mention what the tool returns (e.g., created workgroup ID) or any error conditions, leaving behavioral expectations incomplete.
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?
The schema has 0% description coverage; the description fully compensates by explaining each parameter: name, type with allowed values ('DEPARTMENT', 'LOCATION', or 'SQUAD'), parent_id as optional UUID, and key as optional unique key. This adds significant meaning beyond the bare schema titles.
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: 'Create a new workgroup (DEPARTMENT, LOCATION, etc.)'. It distinguishes from siblings like list_workgroups and delete_workgroup by explicitly using 'Create' and enumerating workgroup types.
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 that this tool creates workgroups and lists the valid types. It doesn't explicitly mention alternatives or exclusions, but the resource type is distinctive and the intended usage is obvious from the name and description.
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 states the read-only listing behavior and return shape ('A list of blueprints with their details and base configurations'), but does not mention pagination, permissions, or the extent of '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 short sentences deliver purpose, parameter semantics, and return shape with no fluff. The most important information is 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?
For a simple list tool with two optional parameters and no output schema, the description covers purpose, filters, and return type. It could be more explicit about pagination or required permissions, but these are minor gaps for this complexity level.
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 0%, so the description compensates by explaining category as an optional filter with examples and query as an optional search. This adds useful meaning beyond the raw schema, though query could be more specific.
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 ('List'), identifies the resource ('workflow pipeline blueprints'), and clarifies scope ('all available... that can be instantiated'). This clearly distinguishes it from siblings like list_pipelines and get_blueprint.
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 usage as a catalog for blueprints available for instantiation, but it does not explicitly state when to use this tool versus list_pipelines or get_blueprint. No exclusions or alternatives are mentioned.
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?
No annotations are provided, so the description carries the full burden. It discloses the return value structure (ID, name, label, type, validation, options), which adds behavioral context beyond the schema. However, it does not explicitly state that it is a read-only operation or mention any potential side effects, though 'list' implies no mutation.
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 main purpose, and every sentence adds value. The return format is efficiently summarized 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 simple zero-parameter list tool with no output schema, the description adequately covers what is returned and the scope. It could mention sorting or pagination, but these are not critical for a basic list of custom fields and are not required by the tool's simplicity.
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 tool has zero parameters, so the schema defines nothing. The baseline for 0 params is 4, and the description does not need to explain parameters. The description adds no parameter info, but none is needed.
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 verb ('List'), the specific resource ('registered global custom fields'), and the scope ('in the organization'), distinguishing it from sibling tools like list_pipelines or list_vendors. It unambiguously identifies what is returned.
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 usage is implied by the 'list' verb and the resource, but the description does not explicitly mention when to use this tool instead of alternatives (e.g., create_custom_field, update_custom_field) or any prerequisites. No exclusions or alternative tool guidance is provided.
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 burden. It discloses that only active members are returned and includes the output fields (IDs, names, emails, roles, status), which is useful. However, it omits details like pagination, sorting, or case sensitivity, leaving some behavioral gaps.
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 with no redundancy. It efficiently covers purpose, parameter semantics, and return value, earning every sentence.
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?
This is a simple list tool with one optional parameter and no output schema. The description adequately covers what it does, what the parameter does, and what the response contains. It is complete enough for typical use, though it could mention whether the filter is case-insensitive or partial.
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 schema only provides 'query' as a nullable string, providing zero description coverage. The description adds meaning by explaining it is an optional search string that filters by full name, which is essential for correct invocation.
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 lists all active members in the organization, using a specific verb 'List' and the resource 'members'. It distinguishes from sibling tools that operate on pipelines, processes, vendors, etc., eliminating ambiguity.
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: lists active members and supports an optional query filter by full name. No explicit when-not or alternatives, but given the unique resource (members) among siblings, this is sufficient for a simple tool.
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 description discloses the return content ('List of pipeline templates with their required header schemas') and adds a critical note about preferring 'id' over the legacy 'pipeline_id'. As a non-annotated, read-only list operation, this covers key behavioral aspects, though it omits permission requirements and potential pagination 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 three sentences, each conveying essential information: purpose, return type, and a usage caveat. No redundant or unnecessary content.
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 zero-parameter listing tool, the description is fairly complete, specifying the return type and an important id-related instruction. A minor gap is that it does not clarify whether the list is filtered by permissions or workspace, but this is not critical for the tool's core function.
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 tool accepts no parameters, so the description has nothing to add beyond the schema. Per the rubric, a no-parameter tool receives a baseline of 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 clearly states the tool lists workflow templates/pipelines that can be started, using a specific verb and resource. It distinguishes from list_processes by explicitly focusing on templates, not running instances.
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 is a precursor to starting a process, and the note about using 'id' is a useful usage tip. However, there is no explicit guidance on when to use this tool versus alternatives like list_processes or list_blueprints, and no exclusions are mentioned.
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 burden of conveying behavior. It discloses the return type as a tree structure with member details and counts, which implies a read-only operation. However, it does not explicitly state safety or limitations like authorization or whether archived workgroups are included, but for a simple list, this is reasonably 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?
The description is two sentences, front-loaded with the action and resource, followed by a clear return specification. Every word adds value; there is no fluff or 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 no-argument listing tool with no output schema, the description adequately explains the return structure and scope. It covers the hierarchy aspect and member counts, which is the core information needed. Some additional detail about what 'member details' include might improve it, but it is not necessary for basic usage.
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 tool has zero parameters, so there are no parameter semantics to describe. The baseline for no parameters is 4, and the description does not need to explain any parameter 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 uses a specific verb 'List' and resource 'workgroups hierarchy' with clarifying scope '(departments and locations)'. It distinguishes itself from siblings like list_pipelines or list_members by clearly targeting the organizational structure. The mention of a tree structure and member details adds specificity.
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 usage when one needs the organizational workgroup hierarchy, but it does not explicitly mention when to avoid using it or alternate tools. There is no reference to list_members for flat member lists or to other listing tools, so guidance is implicit rather than explicit.
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 burden of behavioral disclosure. It explains parameter semantics and recommends a comment for audit trail purposes, but it does not state whether the decision is final, what side effects occur, or any permission requirements. Some context is added, but significant gaps remain.
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 plus a compact parameter list. It front-loads the purpose, then provides each parameter's semantics in a clear, scannable format. No unnecessary words or redundancy, making it concise and well-structured.
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 description covers all parameters and the key prerequisite (calling get_request_details), but lacks information about return values, post-submission behavior, or error conditions. Since there is no output schema, the description would benefit from at least a brief note on what the caller can expect after submission. It is adequate but not complete.
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?
The description completely compensates for the 0% schema description coverage by defining every parameter: request_id as a UUID of the pending request, status as a value from available_actions, and comment as an optional explanation. This provides meaning far beyond the bare schema property names.
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 and resource: 'Submit a decision on a pending approval request.' This distinguishes it from sibling tools like get_request_details (which retrieves information) and list_pending_requests (which lists requests). The scope is precise and actionable.
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 usage guidance: it instructs the agent to always call get_request_details first to obtain valid action IDs and mandates that the status parameter be sourced from available_actions. This gives clear context and a prerequisite, though it does not mention alternatives or 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full behavioral transparency burden. It explicitly discloses that the tool returns 'Complete Markdown specification text to guide pipeline JSON creation' and enumerates the content types (validation rules, node hierarchies, schema guidelines). This gives clear expectations of a read-only retrieval operation, though it doesn't mention potential authentication requirements or caching behavior, which are minor for this simple getter.
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 long, with the first sentence front-loading the core purpose and content, and the second specifying the return format. Every word earns its place, and there is no fluff or repetition of schema details.
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 zero-parameter, read-only tool that returns rules, the description is complete. It covers what the tool does, what content is included, and the return format. No output schema is required since the return is a Markdown text specification, and the sibling tools provide surrounding context for when this would be used.
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 tool has zero parameters, so the schema is fully complete with 100% coverage. The description adds value by explaining what the returned specification contains, which is useful context beyond the empty schema. Since there are no parameters, the baseline for zero-param tools is 4, and the description meets that by enriching the tool's purpose without needing parameter details.
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 it retrieves the official specification, validation rules, node type hierarchies, and schema guidelines for generating Colba pipeline JSON configurations. This specific verb+resource combination distinguishes it from sibling tools like create_pipeline or list_pipelines, which operate on pipeline instances rather than the generation rules.
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 tool is used when generating new pipeline JSON configurations, but it doesn't explicitly state when to use it over alternatives or provide exclusions. Sibling tools like create_pipeline are clearly for pipeline creation, making the use case inferable, but the absence of explicit when/when-not guidance keeps it at an implied level.
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 burden of behavioral disclosure. It explains the verbose behavior and return representation, but omits details like error handling, read-only nature, or permissions. This adds useful context but is not comprehensive.
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 brief sentences plus parameter clarifications, with the purpose stated first. Every line 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.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description covers the key return aspects (status, node states, context variables) and the verbose difference. It lacks details on error cases or response examples, but for a focused retrieval tool, it is largely complete.
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?
The description adds substantial meaning beyond the schema: it identifies process_id as a UUID and explains the verbose flag's impact on output structure. Schema coverage is 0%, so this compensation is critical and well-executed.
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 begins with a specific verb 'Fetch' and names the exact resource (detailed status, current node states, and context variables) for a specific process. This clearly distinguishes it from siblings like list_processes, which likely provides a summary listing.
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 limits the tool to a specific process (requires process_id) and explains the verbose flag's effect. While it doesn't explicitly name alternative tools for when not to use it, the context is sufficient to infer when to call it relative to siblings.
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?
No annotations are provided, so the description carries the full burden. It discloses that the operation returns a status and created template_id, and notably states it 'requires approval,' which is important behavioral context. However, it does not elaborate on the approval process or other side effects like whether the operation is asynchronous.
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, using two sentences to cover purpose, parameter, and return. Every phrase 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?
For a simple tool with one parameter and no output schema, the description covers the essential aspects: what it does, the parameter, and the return value, including the approval caveat. It is complete enough for an agent to invoke it correctly, though it could briefly mention when to prefer this over create_pipeline to improve decision-making.
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?
The description adds significant meaning beyond the schema by specifying 'blueprint_id: UUID of the blueprint to instantiate.' This clarifies the parameter's format (UUID) and its role, which the schema's generic 'string' type and title do not convey. With 0% schema description coverage, this fully compensates.
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 explicitly states 'Create a new pipeline template in the current organization based on a blueprint,' which is a specific verb and resource. This distinguishes it from sibling tools like create_pipeline by clarifying it operates from a blueprint, and also from list_blueprints/get_blueprint which are read-only.
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 tool is used when you have a blueprint to instantiate, but it does not explicitly state when to use it versus alternatives like create_pipeline. There is no mention of exclusions or prerequisite conditions beyond needing a blueprint_id.
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 are provided, so the description carries the full burden. It discloses the required action values and the session_key fallback, but it does not state what happens after resolution (e.g., irreversible side effects, whether the underlying MCP request proceeds) or what permissions beyond the session key are needed. This leaves some behavioral ambiguity.
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 purpose, followed by concise per-parameter notes. Every sentence adds value, and the exactly-one-of constraint is stated in a single unambiguous phrase.
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 has no annotations and no output schema, the description is mostly complete: it covers purpose, constraints, and defaults. However, it does not describe the return value, error cases, or how to obtain the approval_id, leaving minor gaps for a state-changing operation.
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?
The schema has zero parameter descriptions, and the description fully compensates by explaining the action enum, defining token and approval_id, enforcing the exactly-one-of relationship, and documenting the session_key default. This is precisely the parameter-level detail an agent needs.
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 ('Resolve') and clearly identifies the resource ('a pending MCP human-in-the-loop (HITL) transaction') with an explicit parenthetical defining approve/reject. This directly distinguishes it from siblings like list_pending_requests or submit_decision by focusing on the resolution action.
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 operational guidance: the action must be 'approve' or 'reject', exactly one of approval_id or token is required, and session_key defaults to COLBA_TOKEN. It does not explicitly name alternatives or exclusions compared to related tools, but the intended use is strongly implied.
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 full responsibility for behavioral disclosure. It does reveal the return value (started process ID and initial status) and warns about the template_id pitfall, which helps. Yet it omits details about side effects, whether the operation is synchronous, or any prerequisites beyond the template, leaving gaps in transparency.
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 exceptionally concise, using four short sentences that each deliver unique value: action, template_id guidance, payload guidance, and return format. There is zero fluff, and the most important instruction is 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?
For a two-parameter start action with no output schema, the description covers the essential context: what to pass, how to obtain the correct template_id, and what to expect in return. It is slightly lacking in error conditions or idempotency notes, but the given information is sufficient for most usage scenarios.
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?
The schema provides only names and types with no descriptions, so the description adds critical meaning. It explains that template_id must be the 'id' field from list_pipelines (not 'pipeline_id'), and that payload must match the template's header_schema. This transforms ambiguous parameters into actionable guidance.
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 opens with 'Start a new workflow process under a template,' which uses a specific verb and resource, distinguishing this from sibling listing and detail tools. The scope is precise and directly tied to template usage, leaving no ambiguity about what the tool accomplishes.
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 tool is used to start a process under a template, and it explicitly instructs using the 'id' field from list_pipelines rather than 'pipeline_id'. However, it does not explicitly contrast this with alternatives or state when not to use it, so it stops short of a perfect 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 of behavioral disclosure. It adequately states that the tool creates a pipeline template, requires a pipeline_config conforming to a specification, and returns template details including template_id. It stops short of describing permissions, side effects, or failure modes, but the reference to the generation rules tool indicates where to find deeper 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is efficiently structured with a one-line purpose, per-parameter explanations, and a return clause. Every sentence adds value, and the most critical information (the need to call get_pipeline_generation_rules first) is front-loaded within the pipeline_config explanation.
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 creation tool with nested objects and no output schema, the description provides sufficient context to invoke it correctly: it names the required fields in pipeline_config, points to the rules tool and docs, and reports the key return field (template_id). It could be more complete by outlining error scenarios, but it is adequate for an agent to act.
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?
The schema provides only type information with 0% description coverage, so the description must compensate. It fully explains each parameter: name as a human-readable template name, pipeline_config as a complete JSON workflow config with mandatory start_node_id and nodes list, and description as optional human-readable text. This goes well beyond the schema and provides actionable meaning.
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: 'Create a new workflow pipeline template in Colba.' This clearly distinguishes it from sibling tools like list_pipelines, update_pipeline, and archive_pipeline, making 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 Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a concrete usage directive by instructing the agent to 'Call get_pipeline_generation_rules tool first to inspect the required format.' This establishes a prerequisite and helps the agent avoid errors. It does not explicitly mention when to use alternatives, but the resource specificity implicitly differentiates it from update/archive tools.
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?
There are no annotations provided, so the description carries the full burden. It discloses the content of the return value (lists of new tools, changes, restart alerts), which is useful for setting expectations. It does not describe side effects, but a 'get' operation inherently implies a read-only retrieval, and the description gives enough context for a simple log 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 two sentences long, front-loaded with the action ('Retrieve the Colba MCP Server Update Log and Changelog'), and the second sentence adds valuable detail about the log contents. No wasted words 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?
Given the tool's simplicity (zero parameters, no nested objects, output schema exists), the description fully covers the necessary context. It explains what the tool returns and even highlights the important alert about required client restarts, making it complete for an agent to select and invoke 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?
The tool has 0 parameters, and the schema description coverage is 100% (the schema is empty). With zero parameters, the baseline is 4, and the description does not need to add parameter information. It correctly mentions the resource being retrieved without misleading about inputs.
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 'Retrieve' and identifies a unique resource ('Colba MCP Server Update Log and Changelog'). It clearly distinguishes this tool from all sibling tools, which focus on pipelines, processes, requests, and CRUD operations, none of which relate to an update log.
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 implies the tool is for retrieving server update information and changelogs, and it lists what the log contains (new tools, changes, restart alerts). While it does not explicitly state when to use it versus alternatives, the unique resource makes the usage context obvious. No conflicting alternatives are mentioned.
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 description discloses two important behavioral traits beyond the basic listing function: it mentions that each request includes an 'available_actions list so you know valid statuses,' and it warns about server-side pagination potentially making the list incomplete if total exceeds limit. These are useful insights that go beyond the schema. However, it does not mention authentication, rate limits, or the exact shape of a request item, which would be more complete.
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 well-structured: a one-sentence purpose, a brief note on return content, then parameter explanations, and a final pagination caveat. Every sentence adds value without redundancy. It front-loads the core purpose and provides necessary details in an organized manner, fitting the 'appropriately sized and front-loaded' criterion perfectly.
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 there is no output schema and no annotations, the description is expected to cover return values and behavior. It mentions the available_actions list and pagination behavior, which are key aspects, but it does not describe the full structure of each request (e.g., request ID, submission date). For a simple list tool with two parameters, this is a minor gap, so the description is largely complete but not exhaustive.
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?
The schema provides no descriptions for 'limit' and 'offset', so the description carries the full burden. It compensates well by explaining each parameter: 'limit: Max results to return (default: 50, max: 200)' and 'offset: Pagination offset (default: 0).' This adds critical details like the maximum limit and defaults that are not available in the schema, making the parameter semantics fully clear.
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: 'List pending approval requests waiting for this member's decision.' It uses a specific verb (List) and a specific resource (pending approval requests), and the scope ('waiting for this member's decision') differentiates it from sibling tools like list_processes or get_request_details. The name itself is also descriptive, but the description adds necessary context about the decision 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 provides clear context by specifying the tool is for listing requests 'waiting for this member's decision,' which implies use when you need to see approvals requiring action. It does not explicitly name alternatives or exclusions, but the scope is sufficiently defined to distinguish it from related tools like submit_decision or get_request_details. This meets the 'clear context, no exclusions' level.
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 disclosing behavior. It clearly states the action ('list') and the return format (IDs, names, profiles), implying a read-only operation. It does not describe any side effects, permissions, or pagination, but given the simplicity of the tool, this is reasonably transparent. The description adds value beyond the name by specifying the output structure.
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 exactly two sentences: the first states the purpose, the second states the return value. There is no redundant information, and it is front-loaded with the primary action. Every word earns its place, making it highly efficient and easy to parse.
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 list tool with no parameters and no output schema, this description is complete. It tells the agent exactly what will happen ('list all') and what to expect in the response (IDs, names, profiles). There are no hidden behaviors or missing prerequisites. The tool's low complexity does not demand additional explanation.
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 tool has zero parameters, so the baseline of 4 applies. The description adds no parameter-specific information because none exists, but it does clarify what the tool returns, which is useful for an agent. Since the schema is empty, the description's mention of the return fields is the only semantic guidance available.
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 ('List') and resource ('registered vendors/counterparties'), plus scope ('all' and 'in the organization'). It immediately distinguishes itself from sibling mutation tools like create_vendor and delete_vendor, as well as other list tools by explicitly naming the resource type.
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 what the tool does—listing all registered vendors—and implicitly indicates when to use it (when needing an overview of vendors). However, it does not explicitly mention when not to use it or alternative tools, such as using create_vendor to add a vendor or delete_vendor to remove one. This clear context without exclusions aligns with a 4.
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?
Since there are no annotations, the description carries the burden. It discloses that the tool returns detailed information and specifically available_actions, which is crucial for the subsequent submit_decision step. The read-only nature is implied by 'Fetch' but not explicitly stated, and there is no mention of permissions or errors.
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, with three short sentences. The first sentence states the purpose, the second gives usage guidance, and the third explains the parameter. No waste.
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 tool's single parameter, no annotations, and no output schema, the description adequately covers what the tool does, what it returns, and when to use it. The mention of available_actions provides enough context for the agent to understand its role in the approval workflow.
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?
The only parameter, request_id, is explained in the description as a 'UUID of the pending approval request', adding format and semantic context beyond the bare schema type. This fully compensates for the 0% 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 clearly states the tool 'Fetches detailed request information' and specifies the key components (audit history, context payload, available_actions). It distinguishes itself from siblings like get_process_details and submit_decision by naming the specific resource and its role in the approval workflow.
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 strong usage guidance with 'Always call this before submit_decision' and explains why (to know valid action values). However, it doesn't mention alternatives or when not to use the tool, such as when a simple list would suffice via list_pending_requests.
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 full behavioral burden. It discloses role-based filtering ('visible to the member') and the server-side pagination behavior ('list may be incomplete if total > limit'), which are critical for the agent to understand the tool's limits.
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 main purpose. Every sentence adds value: role-based filtering, parameter definitions, and a crucial pagination warning. No redundant or vague wording.
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?
Despite lacking an output schema and annotations, the description sufficiently covers the tool's purpose, all parameters, filtering behavior, and pagination caveat. It provides enough context for reliable invocation for a listing tool.
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?
The description provides rich semantics for all four parameters beyond the schema, including the default and max for limit, and cross-reference to list_pipelines for pipeline_id. This fully compensates for the schema's lack of descriptions.
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 ('List all processes'), the resource ('processes'), and the scope ('visible to the member'), effectively distinguishing it from sibling tools like list_pipelines and get_process_details.
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 filtering options (status, pipeline_id) and pagination parameters, giving clear context for usage. However, it does not explicitly contrast with alternatives such as get_process_details for single-process retrieval or list_pending_requests for pending items.
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:

[![colba-mcp MCP server](https://glama.ai/mcp/servers/mysiteby/colba-mcp/badges/card.svg)](https://glama.ai/mcp/servers/mysiteby/colba-mcp)

Score Badge

Copy to your README.md:

[![colba-mcp MCP server](https://glama.ai/mcp/servers/mysiteby/colba-mcp/badges/score.svg)](https://glama.ai/mcp/servers/mysiteby/colba-mcp)

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/mysiteby/colba-mcp'

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