ICCPlus MCP

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 resources and actions, such as project lifecycle, entity CRUD, CSS, validation, and import/export. The main ambiguities are update_entity versus patch and import_fragment versus create_entity, but the descriptions provide enough scope detail to choose correctly.
Naming Consistency4/5
All tools share the iccplus_ prefix and snake_case, and the majority follow a verb_noun pattern such as create_project, delete_entity, and set_asset. A few noun-only or verb-only names like capabilities, schema, query, and history are minor deviations from an otherwise consistent convention.
Tool Count3/5
27 tools is above the typical well-scoped range and sits just past the heavy 16-25 band. The broad domain—project sessions, entity modeling, CSS management, validation, and viewer building—justifies much of the surface, but some operations could potentially be consolidated.
Completeness4/5
The tool set covers the main project lifecycle, entity CRUD, querying, validation, normalization, import/export, CSS, assets, and viewer building. Minor gaps include no explicit project deletion/rename and no direct get-entity-by-id helper, though JSON Pointer reads and query cover most practical needs.
Average 3.3/5 across 27 of 27 tools scored. Lowest: 2.2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 6 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations offer no hints (readOnlyHint=false, destructiveHint=false), so the description must carry the burden. It implies mutation through actions like 'migrate', 'repair', and 'rebuild', but omits critical safety context such as the dry_run default, validation_policy behavior, and potential side effects on existing data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, but it lists four actions without prioritizing the most critical behavioral elements. It is not front-loaded with the dry_run safety mechanism or validation policy, so while compact, it lacks effective structure for agent decision-making.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With four parameters, no output schema, and no supporting annotations, the description is far too thin. It omits the dry-run default, validation policy semantics, expected_revision's role, and any warnings about non-idempotency or potential data loss, leaving the agent to guess at safe usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description mentions none of the four parameters (dry_run, project_id, expected_revision, validation_policy). The agent must rely solely on parameter names and schema defaults, which is insufficient given the safety implications of dry_run and validation_policy.
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 lists four concrete operations—migrate legacy shapes, generate missing ids, repair indices/parents, and rebuild memberships—clearly indicating the tool's purpose. It is specific enough to distinguish it from generic validation or update tools, though it does not explicitly contrast with siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/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 like iccplus_validate, iccplus_patch, or iccplus_project_status. The description provides no context on the appropriate conditions or scenarios for running normalization.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this as destructive and non-read-only. The description adds value by noting atomicity and optional validation, which are not in the annotations. However, it omits key behavioral traits such as overwrite semantics, conflict handling via expected_revision, and what happens on failure. While it supplements annotations, the coverage is incomplete 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.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no filler. It front-loads the primary purpose and includes two key qualifiers (atomic, optional validation). While it could benefit from a list of parameters or more detail, the structure is clean and the text is appropriately terse.
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 7 parameters, no output schema, and destructive annotations, the description is far too brief. It doesn't explain return values, error handling, or the behavior of overwrite, expected_revision, or create_directories. The atomicity and validation mentions are useful but insufficient for an agent to safely invoke this tool without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/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 explain the parameters, but it doesn't. It only hints at 'strict validation' which maps loosely to require_valid. The other six parameters (path, pretty, overwrite, expected_revision, create_directories) remain entirely unexplained, leaving the agent to guess their meaning from names and defaults alone.
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 (atomically save), the resource (project JSON), and the location (inside ICCPLUS_WORKSPACE). It goes beyond a tautology by adding atomicity and validation context. However, it doesn't differentiate from sibling tools like create_project or update_entity, which might also save project data, leaving some ambiguity about when this specific save operation is intended.
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 mentions 'optional strict validation' but doesn't clarify under what circumstances validation should be skipped or enabled, nor does it name alternative tools or exclusions. An agent would struggle to decide between this and similar operations like create_project or patch.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses that the tool mutates a field, but it does not say whether it overwrites existing values, whether the project must first be open or saved, how revision checks or validation policies affect the write, or what side effects a successful set has. Annotations are all false and carry no safety or idempotency information, so the description bears the full burden and does not meet it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one efficient sentence that front-loads the core action and key constraint. It is not padded, but the awkward 'from a workspace file as a data URL' phrasing slightly hurts readability and precision.
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 mutation tool with 8 parameters, no output schema, no parameter descriptions, and no helpful annotations, this one-sentence description is insufficient. It establishes intent but omits critical operational details such as the source_path vs url distinction, media_type requirements, dry_run behavior, and validation/revision semantics.
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?
With 0% schema description coverage across 8 parameters, the description must compensate, but it only clarifies the idea of a JSON Pointer target and data-URL source. It leaves url, source_path, media_type, dry_run, expected_revision, and validation_policy essentially unexplained, so an agent cannot reliably distinguish source_path from url or know why validation_policy and expected_revision exist.
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 ('Set'), the target resource ('any string field ... using an exact JSON Pointer'), and the two source modes ('workspace file' or 'external/data URL'). It is specific enough to distinguish this from generic patch/update tools, though the phrase 'from a workspace file as a data URL' is slightly tangled and the title's 'image or audio asset' sounds narrower than 'any string field'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no when-to-use guidance, no conditions, and no mention of alternative tools such as iccplus_css_set, iccplus_patch, or iccplus_update_entity. It only states the mechanism ('using an exact JSON Pointer'), which is a requirement rather than a usage criterion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral details like applying loading config and optional deduplicated image separation, which are not in annotations. However, it does not disclose potential side effects such as overwriting output or modifying the project, and the destructive hint is only in annotations. More transparency about side effects and failure modes would improve.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence with no extraneous content. It efficiently conveys the main action and optional components.
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?
While the main action is clear, the description lacks context about the output format, how parameters affect the result, and any prerequisites. There is no output schema, and the tool has 8 parameters with minimal guidance, making it incomplete for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only template_path has a description; the other seven parameters are undocumented. The description mentions loading config and image separation but does not map them to specific parameters. With low schema coverage, the lack of parameter descriptions leaves the agent guessing about required 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 clearly states the tool's function: packaging the project into a viewer template, with specific details about loading config and optional image separation. It distinguishes from sibling tools by focusing on building an archive, not on editing or exporting fragments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool over alternatives. It does not mention any conditions or scenarios where this tool is preferred, leaving the agent without selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, and the description's 'Search' is consistent with those. However, the description adds no behavioral context beyond that: it does not mention result shape, pagination, matching semantics, or the effect of include_values/include_embedded_assets, which are already partially described in the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no wasted words and front-loads the core action ('Search'). It is concise, but the brevity sacrifices the behavioral and parameter guidance needed for a tool with eight parameters.
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 an 8-parameter, no-output-schema tool in a crowded sibling set, this description is not complete enough. It fails to specify return shape, pagination, query semantics, or when this search tool should be chosen over read/schema/export siblings, leaving agents to rely on inference.
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?
With only 25% schema description coverage, the description needed to compensate, but it barely does. It lists plural entity categories such as 'designs', 'addons', and 'requirements' that map imprecisely to the schema's enum values (e.g., row_design_group vs choice_design_group, addon vs selectable_addon), and it gives no meaning for project_id, ids, query, limit, or offset.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'Search' and identifies the resource as ICC Plus entities, then lists the entity kinds it covers. This differentiates it from mutation tools like iccplus_update_entity or iccplus_delete_entity, though it does not explicitly contrast with iccplus_schema or iccplus_read_project.
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 prefer this tool over siblings such as iccplus_schema, iccplus_read_project, or iccplus_export_fragment. The verb 'Search' implies a read/list use case, but no context, exclusions, or alternative routing 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?
Annotations provide no positive behavioral hints—readOnlyHint, openWorldHint, idempotentHint, and destructiveHint are all false—so the description carries the burden. It does disclose useful creation behavior: current project defaults, optional overrides, automatic ids, and normalized memberships. However, it does not mention side effects, validation behavior, dry_run capability, or persistence implications, which are relevant 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that front-loads the core purpose and then lists high-level behaviors without wasted words. It is readable and scannable, and every phrase adds meaning about how the tool behaves.
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 8 parameters, low schema coverage, no output schema, and a large sibling set, this description is too thin to fully support correct invocation. It omits the role of validation_policy, dry_run, expected_revision, and position, and does not clarify how 'normalized memberships' or 'overrides' relate to the input structure. An agent would likely need to inspect the schema or experiment to understand critical behaviors.
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?
Schema description coverage is only 13%, with only 'parent' documented, so the description must compensate heavily. It introduces concepts like 'overrides', 'automatic ids', and 'normalized memberships', but these are not explicitly mapped to parameters such as values, parent, or expected_revision. Important parameters like dry_run, validation_policy, position, and project_id receive no semantic guidance beyond schema constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb and resource: 'Create any modeled ICC Plus entity.' It adds behavioral specifics—current project defaults, optional overrides, automatic ids, normalized memberships—that go beyond the title. However, it does not explicitly distinguish itself from siblings like iccplus_create_project or iccplus_duplicate_entity, relying on the word 'entity' to imply the separation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no explicit guidance on when to use this tool versus alternatives such as iccplus_duplicate_entity, iccplus_update_entity, or iccplus_patch. It implies broad use for entity creation via 'any modeled ICC Plus entity,' but does not mention prerequisites like having a project open, or when a different creation path would be more appropriate. This leaves selection largely to inference from the sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already carry the destructive profile (destructiveHint=true, readOnlyHint=false), and the description adds one useful behavioral context: the default policy rejects deletions that create dangling references. However, it does not disclose whether deletions are reversible, what happens to dependent entities beyond the rejection, or what a successful delete returns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the operation and then the key behavioral constraint, with zero filler. Every clause earns its place.
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 six parameters, no output schema, zero schema descriptions, and a destructiveHint, the definition should explain parameter meaning, dry_run semantics, and success/failure behavior — none of which are present. This is comparable to the update_drive calibration case (4 params, 50% coverage, no annotations), which was also scored 2 for incompleteness.
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?
Schema description coverage is 0%, so the description bore the duty to explain reference, type, dry_run, expected_revision, and validation_policy — and it explains none of them by name. The default-policy sentence does give practical meaning to the default validation_policy value ('no_new_errors'), but that is partial credit at best.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Delete') and resource ('one entity'), and the 'one' qualifier rules out bulk deletion, adding precision over the title. The operation is unambiguous among the sibling set, which contains only create/update/duplicate/move/patch as mutation alternatives, though the description does not explicitly name a sibling to differentiate from.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no explicit when-to-use guidance and names no alternatives such as update_entity or patch for modifying rather than removing an entity. The dangling-reference note hints at validation considerations but does not tell the agent when to prefer this tool or how to avoid the default rejection (e.g., via dry_run).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide destructiveHint=true, so the mutation risk is known. The description adds the valuable behavioral detail of atomicity and references the RFC 6902 standard, which informs expected patch semantics. However, it does not mention revision conflicts, validation behavior, or dry-run effects, which are relevant for a destructive patch operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It communicates the core action, the atomicity guarantee, and the scope in a compact and scannable way.
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 destructive, multi-parameter patch tool with no output schema, a one-line description is under-specified. It omits important context around revision handling, validation policies, dry-run behavior, and what the operation returns or affects, leaving the agent to infer critical execution details.
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?
Schema description coverage is 0%, so the description must compensate, but it only clarifies the nature of 'patches' by referencing RFC 6902. The other parameters—project_id, dry_run, expected_revision, validation_policy—receive no explanation beyond their names and schema constraints, leaving significant semantic gaps for the agent.
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 tool applies RFC 6902 JSON Patch operations, identifying both the mechanism and the target resource. It conveys atomicity and a broad field scope, which helps distinguish it from entity-specific or field-specific siblings, though it does not explicitly name any sibling alternative.
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 choose this tool over alternatives like iccplus_update_entity, iccplus_css_set, or iccplus_set_asset. The phrase 'for any current or future ICC Plus field' hints at broad applicability, but no when-to-use or when-not-to-use conditions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful context about what the list contains ('source evidence' and 'project-specific escaped selectors'), which goes beyond the schema. It does not mention pagination or result ordering, but given the annotation coverage, this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, dense sentence that front-loads the primary action and object. It is concise and avoids fluff, though it uses jargon like 'escaped' and 'source evidence' that may require domain knowledge. Still, it earns points for efficiency.
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 6 parameters, no output schema, and low schema coverage, the description is too brief to be fully complete. It does not explain the distinction between 'official' and 'project' scopes, what 'source evidence' means, or what the returned data looks like. An agent would need to infer many details from names and context, which is risky for correct invocation.
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?
Schema description coverage is only 33% (only query and project_id have text). The description does not compensate by explaining kind, scope, limit, or offset semantics. With low coverage and no description-level guidance, parameters like kind and scope remain underdocumented, leaving the agent unsure how to use them effectively.
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 tool lists official viewer classes and project-specific selectors, with a specific verb ('List') and resource. It does not explicitly differentiate from siblings like iccplus_css_analyze or iccplus_css_set, but the purpose is unambiguous and specific enough to be distinguished from them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as iccplus_css_analyze or iccplus_css_set. There is no mention of typical use cases, prerequisites, or exclusions. An agent must infer usage from the name and sibling context.
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?
It mentions 'fresh ids' and 'remap references' but does not state side effects on the original entity (e.g., whether it is left unchanged). The annotations indicate destructiveHint=false and readOnlyHint=false, which are consistent but the description itself provides only partial 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 a single concise sentence that front-loads the primary action. It omits unnecessary details and is immediately comprehensible.
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?
The description does not cover return values, failure modes, or the purpose of parameters like expected_revision and validation_policy. With no output schema and vague parameter hints, context is incomplete for a complex operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description mentions none of the eight parameters, despite the schema defining required fields like project_id and reference, and enums for type and validation_policy. No parameter is explained, leaving users to guess their 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 clearly states the tool duplicates an entity with nested content, assigns fresh ids, and optionally remaps references. The verb 'duplicate' is specific and distinct from other entity operations like create or update, so purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains what it does but gives no guidance on when to use it versus alternatives (e.g., when to duplicate vs create). It lacks explicit conditions like 'use this when you need a deep copy without affecting the original.'
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate a write operation that is not idempotent and not destructive, which already covers the basic safety profile. The description adds some behavioral context by mentioning the normalization layer and parent/default handling, but does not disclose side effects, validation behavior, or how the fragment is persisted or returned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler and the core action is front-loaded. It is appropriately terse, though the phrase 'parent/default/normalization layer' is slightly dense and could be simplified without losing meaning.
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 9 parameters, a nested value object, multiple enums, no output schema, and a broad sibling set, the one-sentence description is substantially incomplete. It does not mention return values, failure modes, dry-run semantics, or what differentiates this from create_entity, making it insufficient for confident invocation without external schema exploration.
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?
Schema description coverage is 0% with 9 parameters, so the description carries the burden of explaining parameters, but it only alludes to parent/default/normalization. It does not clarify the 'value' fragment structure, 'type' enum semantics, dry_run behavior, preserve_ids, expected_revision, or validation_policy, leaving most parameters underspecified.
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 names a specific verb ('Import') and resource ('ICC Plus fragment'), and adds context about using the same normalization layer as normal entity creation. It is clear enough to distinguish from export_fragment, though it does not explicitly contrast with create_entity or other sibling import-like operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'same parent/default/normalization layer used for normal entity creation' implies this tool is for importing fragments with consistent behavior to entity creation, but it never states when to use this over create_entity, normalize, or export_fragment. No alternatives are named and no exclusions or preconditions are given, so usage guidance is only 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?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that the tool extracts evidence from ICC Plus and lists the evidence types, which is consistent with the annotations and provides some context. However, it doesn't describe the return structure, pagination, or what happens when no topic is given beyond listing families. With annotations covering the core behavior, a 3 is appropriate—some added context but not rich behavioral disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the primary action and then enumerates the evidence types. It's concise and readable, though the long list makes it slightly dense. No wasted words, and the key purpose is stated upfront.
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 tool with 5 optional parameters and no output schema, the description doesn't explain what the response looks like (e.g., a list of families, a structured index, or function bodies). The topic parameter's syntax is covered by the schema, but the description could mention that the result is a list or index to set expectations. Since it's a read-only discovery tool and the schema is rich, a 3 feels adequate—it's not incomplete enough to mislead, but it could give more detail on return format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so every parameter (file, limit, topic, offset, include_source) already has a detailed description in the schema. The tool description adds no additional parameter-level semantics beyond what the schema provides. Baseline 3 is correct—the schema does the heavy lifting, and the description doesn't need to compensate.
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 tool's function: 'List feature families or return field, type, function-body, source-file, deployment-artifact, or Custom CSS evidence extracted from ICC Plus.' It names a specific verb and resource, and enumerates the kinds of evidence returned. It distinguishes itself from siblings like iccplus_schema or iccplus_css_catalog by being a broader discovery tool, though it doesn't explicitly name any sibling. Slight ambiguity remains around what 'feature families' means, but the core purpose is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus its many siblings (e.g., iccplus_schema for schema details, iccplus_css_catalog for CSS specifics). There is no explicit when-to-use or when-not-to-use, nor any mention of alternatives. The only usage hint is 'Omit to list all feature families,' which is a parameter behavior, not a selection guideline. An agent would have to infer from sibling names and the description that this is a general discovery entry point.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate read-only, idempotent, non-destructive behavior; description adds that it returns an explainable trace, providing additional clarity on output.
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, conveying the essential action and output in one sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Without an output schema, the description gives only a vague notion of the return (explainable trace); it fails to describe error handling, detailed behavior, or parameter interdependencies for a complex tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is only 25% with only entity having a description; the tool description adds no parameter explanations, leaving state, project_id, and requirements ambiguous.
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 it evaluates an entity or requirement tree using ICC Plus operator semantics and returns an explainable trace, distinguishing it from other tools like validate or normalize.
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 for evaluation but does not explicitly contrast with alternatives like iccplus_validate or iccplus_normalize; the purpose is clear enough but guidance is implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already convey the safety profile: readOnlyHint=true, openWorldHint=false, idempotentHint=true, destructiveHint=false. The description adds only that the tool returns reusable JSON, which is modest but consistent. No additional behavioral details such as output shape, error conditions, or asset handling are disclosed, though annotations lower this burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, direct sentence with no filler. The core action and result are front-loaded, making it easy for an agent to quickly parse the tool's purpose.
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, low parameter coverage, and a wide enum of possible type values, the description should explain more about what 'reusable JSON' contains and how to construct the reference. It leaves important operational details such as how to identify the target entity and what the exported JSON looks like entirely unstated.
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?
Schema description coverage is only 25% because only include_embedded_assets has a description. The description lists some entity kinds but does not explain the meaning of 'reference', the format of project_id, or how type values map to behavior. The schema's enum already lists valid types, so the description adds little semantic value for the parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Return') and resource ('a row, choice, addon, score, requirement, or feature entity as reusable JSON'), which makes the tool's basic function obvious. However, it does not explicitly differentiate this from siblings like iccplus_query or iccplus_read_project, and the term 'feature' is not actually present in the type enum.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'as reusable JSON' implies this is intended for serializing/exporting a fragment for later reuse, giving some contextual signal about when to use it. But it does not explicitly say when to prefer this over alternatives like query, read_project, or import_fragment, and provides no exclusion criteria.
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 goes beyond the sparse annotations by disclosing that updates are deep merges, that fields can be unset, and that ID changes may rewrite all modeled references—a meaningful side-effect warning. It does not use destructiveHint despite potential reference rewrites, but this is not necessarily a contradiction because the operation updates rather than deletes. It could add dry-run or validation behavior, but the annotation set is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero filler, front-loaded with the main action and then a critical side effect. Every sentence earns its place.
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 nine parameters, nested values, no output schema, and sparse annotations, the short description leaves important context unexplained: return values, failure or validation behavior, and when to use this versus iccplus_patch. It also does not mention dry_run or validation_policy, which are significant for safely exercising this mutation.
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?
It adds semantics for 'values' (deep-merged rather than replaced), 'unset' (explicit field removal), and ID/reference rewriting, which are not obvious from the bare schema. However, schema coverage is only 11%, and several parameters such as dry_run, expected_revision, validation_policy, and type receive no explanatory benefit from the description.
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 names a specific operation—deep-merging fields into an entity and optionally unsetting fields—and adds a notable side effect about ID changes rewriting modeled references. It clearly identifies 'one entity' as the resource, though it does not explicitly distinguish itself from the similar sibling iccplus_patch.
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 explicit guidance about when to choose this tool over siblings such as iccplus_patch or iccplus_create_entity. The 'update' title and merge semantics imply it is for modifying an existing entity, but the description does not state exclusions, prerequisites, or alternative selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by listing the concrete invariant categories checked and noting the checks are 'generated.' It does not describe the return shape, but that is secondary given the strong annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every phrase adds a distinct validation category, and the verb-object relationship is immediately clear. It is appropriately sized for the tool's straightforward scope.
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 provides a thorough inventory of what is validated, and the annotations cover side-effect safety. However, it lacks output expectations and any usage context, and with zero parameter semantics an agent can select the tool but must rely on schema defaults and inference to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description contributes almost no parameter information. It does not explain what `structural` toggles, what `max_diagnostics` limits, or how `project_id` is used beyond being the project identifier. The agent is left to infer parameter meaning from property names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb ('Run') and a clear object: generated structural schema checks for an ICC Plus project. It then enumerates the exact categories (ids, references, requirements, memberships, cycles, Custom CSS, export invariants), making its scope distinct from siblings like iccplus_evaluate_requirements or iccplus_project_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of conditions, prerequisites, exclusions, or a preferred workflow such as running validation before export. The description states what the tool does but not when an agent should choose it over other validation-related siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already indicate destructive behavior, and the description adds that this closes an in-memory session and that unsaved sessions require force=true. It stops short of explicitly disclosing that forcing will discard unsaved changes or what exactly happens to the session state, so the added behavioral context is useful but incomplete.
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 tight sentences with no filler. The core action is front-loaded, and the force requirement is presented as a concise, necessary caveat.
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 that this is a destructive, mutating operation with no output schema, the description is not complete enough for safe invocation. It fails to explain expected_revision, the consequences of force, or any return/error behavior, which are important for an agent deciding whether and how to call this tool.
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?
Schema description coverage is 0%, so the description must compensate for parameter meaning. It does clarify the force parameter's key condition, but it gives no guidance on project_id's role and completely omits expected_revision, which is likely a concurrency guard and is left unexplained.
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 ('Close') and resource ('in-memory session'), and the title clarifies the resource is the ICC Plus project. It is clearly differentiated from siblings like open_project, save_project, and read_project.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when closing an in-memory session, with the additional condition that unsaved sessions require force=true. However, it does not explicitly contrast this with save_project or any alternative, nor does it say when closing without force is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, and the description adds useful context by saying the analysis is 'static' and applies to 'stored or candidate' CSS. It does not describe the output or diagnostic behavior, but nothing contradicts the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, dense, well-structured sentence that front-loads the verb and resource and then lists the analysis dimensions. Every clause adds meaningful information, and there is no repetition of annotation or schema data.
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 read-only static analysis tool, the description covers the main inputs and analysis areas reasonably well. But because there is no output schema, the agent is left without explicit information about what the tool returns, and the two undocumented parameters remain unexplained, leaving gaps in fully anticipating the tool's behavior.
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 describes `css` and `project_id`, and the description reinforces those semantics with 'stored or candidate CSS'. However, `include_rules` and `max_diagnostics` have no descriptions in either the schema or the tool description, so the description does not fully compensate for the 50% schema coverage gap.
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 names a specific verb and resource: 'Statically analyze stored or candidate CSS' and enumerates concrete analysis dimensions like syntax, selector specificity, official classes, project ids, inline-style conflicts, and external assets. This makes the tool's purpose clear, though it does not explicitly differentiate it from siblings like iccplus_css_catalog or iccplus_css_set.
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 gives clear context for when the tool applies: when analyzing either stored project CSS or a candidate CSS string. However, it never names alternatives or states when not to use this tool, so the agent must infer boundaries from the sibling names rather than from explicit guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations only provide false hints for readOnly, idempotent, and destructive, so they do not characterize this as a mutation. The description steps in by explicitly stating the move effect and the 'repair stored indices' side effect. It also narrows scope to the current container, adding useful behavioral context beyond annotations. It does not discuss effects on sibling ordering or reversibility, but core behavior is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence containing no filler. Every phrase adds value: the verb, the container scope, and the index-repair effect are all present with zero waste.
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 7-parameter mutation tool with no output schema and zero parameter descriptions, an 11-word description is materially incomplete. An agent would not know how reference and type relate, what dry_run does, when validation_policy matters, or whether prerequisites like an open project apply.
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?
Schema description coverage is 0%, so the description carries the burden of explaining 7 parameters. It only weakly implies that 'position' is the target index and 'reference' identifies the entity. It says nothing about type, dry_run, expected_revision, or validation_policy, leaving the agent without meaningful parameter 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 states a specific verb ('Move'), a precise resource ('an entity within its current ordered container'), and a relevant side effect ('repair stored indices'). This clearly distinguishes it from sibling operations like create_entity, update_entity, or delete_entity.
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. Sibling tools such as update_entity and duplicate_entity exist, but the description never explains what makes move the right choice or mentions any conditions/exclusions. Usage must be inferred entirely from the name and context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the 'generated' provenance and the summary/definition/full scoping, but does not describe output details or how the two optional parameters interact.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single focused sentence with no filler. It front-loads the action and clearly enumerates the three read modes without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only tool with only two optional parameters and strong readOnly/idempotent/destructive annotations, the description is largely complete. It does not specify the exact JSON return shape or combined-parameter behavior, but the 'or' phrasing and JSON Schema context make the intended usage reasonably clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3; the schema already explains `full` and `definition` with useful examples. The tool description maps those parameters to three modes but adds little meaning beyond what the input schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Read') and resource ('generated JSON Schema summary, one definition, or the complete project schema'), giving three clear scopes. It is not tautological and the title reinforces the purpose, but it does not explicitly differentiate from sibling tools like iccplus_read_project or iccplus_capabilities.
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 three usage modes matching the optional parameters: summary, a single definition, or the complete schema. However, it gives no explicit when-to-use guidance, no exclusions, and no mention of when a sibling tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already flag destructiveHint=true and readOnlyHint=false, and the description adds genuinely useful behavioral context beyond them: revision protection (concurrency guard), dry-run support (preview before applying), and integrated validation (policy-gated writes). It clearly identifies the affected field ('customCSS'), so the destructive scope is disclosed. It doesn't detail rollback or failure semantics, but the safety mechanisms are well surfaced.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single 22-word sentence that front-loads the action verbs, names the exact target field, and appends the three distinguishing features. Every phrase earns its place with zero filler or repetition of schema details.
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 destructive 6-parameter mutation tool with no output schema, the description covers the core concepts (modes, revision guard, dry-run, validation) but omits operational details an agent needs: what the return value looks like, what happens when the revision check fails or validation fails, and whether the project must be open first. Adequate conceptually, but with clear gaps at the edges.
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?
With only 17% schema description coverage, the description carries most of the burden and partially compensates: the verbs map directly to the mode enum values, and 'revision protection', 'dry-run support', and 'integrated validation' correspond to expected_revision, dry_run, and validation_policy. However, it leaves the validation_policy levels (strict vs no_new_errors vs none) and the exact revision-mismatch behavior unexplained, so compensation is high-level rather than complete.
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 names multiple specific verbs (Replace, append, prepend, clear) targeting a precise resource (the official project customCSS field). The 'official' qualifier distinguishes this field-level mutation from sibling CSS tools like iccplus_css_catalog (listing) and iccplus_css_analyze (analysis), so an agent can tell them apart without opening schemas.
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 implies the operation modes via the verbs, but gives no explicit when-to-use guidance, prerequisites, or exclusions relative to siblings. It never names alternatives such as iccplus_css_analyze for validation-only workflows or iccplus_read_project for viewing current CSS, leaving routing entirely to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false, meaning this is not a read-only operation, and the description adds crucial behavioral detail: the project is created in-memory and nothing is written until save is called. This goes beyond what annotations provide and sets accurate expectations about side effects and persistence.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the essential operation and a key constraint (in-memory, nothing written until save). Every word earns its place with no fluff or redundancy.
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 tool with no output schema and two optional parameters, the description covers the core concept but leaves some gaps: it does not specify what the tool returns, whether the new project becomes the active project, or how overrides should be structured. The presence of sibling tools like read_project and save_project partially compensates, but the missing return/state-change details make it minimally adequate.
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?
Schema description coverage is only 50%: the path parameter has a description, but the overrides object is undocumented in the schema and the description does not explain it. The phrase 'from current upstream defaults' hints that overrides may adjust those defaults, but this is implicit and not sufficient for an agent to confidently construct valid override 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 states a specific verb ('Create') and resource ('in-memory project from current upstream defaults'), making the operation clear. It also distinguishes itself from save_project by explicitly noting that nothing is written until save is called, and from open_project by implying this creates a new project rather than opening an existing one.
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 when to use this tool—when starting a new project from default upstream values—and hints that a subsequent save_project call is required to persist it. It does not explicitly name alternative tools like open_project or save_project, but the context provides adequate guidance for an agent to choose correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate destructiveHint=true, and the description adds useful context beyond that: 'in-memory' clarifies the mutation is not persisted, and 'while keeping revision conflict protection' signals that revision checks are enforced. This goes beyond the structured annotations without contradicting them.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that immediately names the operation and the most important constraint. Every word earns its place; there is no wasted text or repetition of title/schema information.
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?
Core behavior and safety profile are covered, making the tool usable for basic invocation. However, it omits prerequisites like an open project, potential errors (e.g., nothing to undo), and the meaning of expected_revision. For a destructive tool with no output schema, this is adequate but not fully complete.
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?
Schema description coverage is 0%, so the description must compensate, but it does not explain any of the three parameters. It only alludes to revision conflict protection without clarifying expected_revision's role or how action enumerations map to behavior. The schema's self-explanatory names and enum provide some guidance, but the description itself adds little.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Undo or redo one in-memory mutation.' This clearly identifies the operation and scope, and it is easily distinguished from sibling tools because none of the siblings mention undo/redo functionality.
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 the tool operates on in-memory mutations of the current project, which implies when it should be used relative to other mutation tools. It does not explicitly mention alternatives or exclusions, but the unique purpose among siblings makes this acceptable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds that the session is 'isolated' and 'revisioned', which are behavioral details not in annotations. It does not contradict annotations and provides useful context about session semantics.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no redundant phrases. It front-loads the core action and location, and every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple open operation with two parameters and no output schema, the description covers the essential context: where the file comes from (ICCPLUS_WORKSPACE) and the nature of the session (isolated, revisioned). The normalize parameter is documented in the schema, so nothing critical is missing for the agent to invoke 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 coverage is 50% – only normalize has a description. The description implies path is a JSON file path (from ICCPLUS_WORKSPACE), which adds some meaning beyond the bare 'path' parameter. However, it doesn't elaborate on normalize, and the description does not fully compensate for the missing path description, though it partially does.
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 ('open') and resource ('project JSON file from ICCPLUS_WORKSPACE'), and states the outcome ('into an isolated revisioned session'). This clearly distinguishes it from siblings like read_project (which likely just reads) and create_project (which creates new projects).
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 provides context (workspace location, isolated revisioned session) but does not explicitly compare to alternatives or state when not to use it. Given the sibling list includes read_project, save_project, and close_project, an agent can infer usage, but there is no direct guidance on choosing this over others.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the output contents but not much beyond that, such as potential payload size or cost of including the project JSON. There is no contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one tight sentence that front-loads the action and lists the full scope of returned information without filler. Every clause contributes meaning, and the optional project JSON is cleanly signaled.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only, non-destructive status tool with only one required parameter, the description plus schema guidance is mostly sufficient: the agent knows what will be returned and how to avoid expensive optional payloads. It is not a 5 because the description does not explicitly distinguish status inspection from the validation or CSS-analysis siblings, and there is no output schema to clarify return shape.
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 67%; the two boolean parameters are well documented in the schema, including strong guidance to prefer iccplus_read_project and to avoid embedded assets unless required. The main description adds only 'optionally project JSON,' which maps to include_project. The project_id parameter lacks prose but has type/format/pattern constraints, so a 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb ('Return') and enumerates concrete status artifacts: revision, dirty state, summary, Custom CSS analysis, validation counts, and optional project JSON. The schema parameter description further distinguishes it from iccplus_read_project by steering bulk project reads to that sibling, so an agent can tell which tool to use.
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 main description gives clear context about the status payload, and the parameter descriptions provide useful routing guidance: prefer iccplus_read_project for complete project reads and keep embedded assets false unless exact encoded contents are needed. It stops short of explicitly stating when to choose this over iccplus_validate or iccplus_css_analyze, so it is not a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavioral context beyond the annotations: the listing is in-memory only, includes dirty state, and returns compact summaries rather than full project content. It does not contradict the readOnly/idempotent/destructive hints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence efficiently conveys the action, scope, and output content without redundancy. All elements earn their place and 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 zero-parameter read-only listing tool, the description is largely complete. It identifies what is listed and the nature of the output. It could be slightly clearer about the exact shape of the summaries, but the lack of parameters and strong annotations keep the burden low.
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 is nothing to explain. The baseline of 4 applies; the description adds no parameter semantics because none are 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?
Description states the specific verb 'list', the resource 'in-memory project sessions', and the contents of the listing ('revisions, dirty state, and compact summaries'). This clearly distinguishes it from tools like read_project or project_status, which operate on individual projects rather than enumerating open sessions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the tool's scope clear: list in-memory project sessions. However, it does not explicitly say when to use this tool instead of siblings such as iccplus_project_status, iccplus_read_project, or iccplus_query. Usage guidance is implied rather than stated with alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, non-destructive behavior, and the description adds meaningful behavioral context beyond those hints: it guarantees exact preservation of CSS, HTML, JS, and unknown fields, and explicitly discloses that embedded assets are redacted by default. There is no contradiction between the description and the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single information-dense sentence that front-loads the action and resource before delivering the key constraints. It includes no filler and every clause earns its place, making it easy for an agent to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description could go further in stating the response shape or behavior for invalid/inaccessible paths, but the tool's purpose is simple enough that an agent can reasonably infer it returns the values at the requested pointers. The schema and annotations provide strong coverage of parameters and safety, and the description fills the important behavior gaps around exactness and asset redaction.
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 covers paths and include_embedded_assets, and the description reinforces and extends this by explaining that JSON Pointer reads preserve exact fields and redact embedded assets by default. This adds practical meaning to the include_embedded_assets parameter that the schema only describes as 'Return raw data URLs.' project_id is only constrained by pattern in the schema and not semantically described, but it is a standard identifier.
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 names a specific verb ('Read'), a precise resource ('RFC 6901 JSON Pointers' within an ICC Plus project), and immediately distinguishes the behavior from a full project read with 'without returning the complete project.' It also communicates the exactness guarantees (CSS, HTML, JS, unknown fields) and default redaction, leaving no ambiguity about the tool's core purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool—when an exact, targeted read is needed rather than the full project—via 'without returning the complete project.' It does not explicitly name alternatives among siblings such as iccplus_query or state when this tool should be preferred, nor does it describe excluded use cases, so the usage guidance is only implicit.
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:

[![ICCPlus-MCP MCP server](https://glama.ai/mcp/servers/Kz2g1ew-commits/ICCPlus-MCP/badges/card.svg)](https://glama.ai/mcp/servers/Kz2g1ew-commits/ICCPlus-MCP)

Score Badge

Copy to your README.md:

[![ICCPlus-MCP MCP server](https://glama.ai/mcp/servers/Kz2g1ew-commits/ICCPlus-MCP/badges/score.svg)](https://glama.ai/mcp/servers/Kz2g1ew-commits/ICCPlus-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/Kz2g1ew-commits/ICCPlus-MCP'

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