Titan Rotation MCP

by brooke19931993-glitch

Overview Schema Related Servers Score Discussions

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have clearly distinct purposes, but overlap exists between titan_start_rotation and the individual getters (spec_data, role_blueprint, template, settings_format) since start_rotation returns all of those. Descriptions mitigate this by positioning start_rotation as the entry point, so confusion is limited.
Naming Consistency5/5
All tool names follow a consistent pattern of titan_<verb>_<object>, using snake_case throughout. Verbs like list, get, resolve, search, and validate are applied uniformly, making the naming predictable and easy to navigate.
Tool Count5/5
With 15 tools, the server sits at the upper edge of the well-scoped range. Each tool serves a distinct role in the rotation-development workflow, from data retrieval to validation, without feeling bloated.
Completeness5/5
The tool surface covers the entire workflow for creating a WoW rotation: discovering specs, retrieving role-specific blueprints, resolving spell IDs, accessing API docs and templates, and validating the final code. No critical steps are missing for the stated purpose.
Average 3.9/5 across 15 of 15 tools scored. Lowest: 2.8/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 3 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?
With no annotations present, the description carries the full burden for behavioral disclosure. It only states the tool returns a signature, omitting details about return structure, safety, side effects, or error behavior. The 'get' in the name implies a read operation, but this is not explicitly stated.
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, front-loaded and free of extraneous words. It efficiently conveys the core purpose without padding.
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 the tool has one parameter, no output schema, and no annotations, the description is extremely thin. It does not explain the return format, how method names map to a list, or any dependent context from sibling tools, leaving the agent to infer most operational 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?
The description adds minimal meaning to the `method` parameter by implying it refers to an API method name. However, it does not explain what constitutes a valid method, where to find allowed values, or how to format the string. With 0% schema coverage, the description fails to sufficiently 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 provides the exact signature of a single API method, distinguishing it from sibling tools like titan_list_api_methods and titan_get_spec_data. Although it lacks an explicit verb, the noun phrase is unambiguous and directly tied to the tool's function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description does not mention that one might first need to list available methods or verify method names before calling this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full behavioral disclosure burden. It only reveals that the result is a canonical template with structure and callbacks, but does not disclose return format, side effects, read-only nature, or any operational characteristics.
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 short sentence, which is appropriately concise for a no-parameter tool. It is front-loaded with the key noun phrase, but it lacks an explicit action verb and is borderline under-specified.
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 simple no-parameter tool, the description gives minimal context: it states the template's subject matter but not how it is returned, how it refers to rotation development, or when it is appropriate to fetch. This leaves significant gaps for an agent deciding to invoke it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the input schema is trivially complete (100% coverage). There are no parameter semantics to elaborate, and the baseline of 4 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the specific resource (canonical rotation module template) and its key components (structure, required callbacks), making the primary purpose clear. It does not explicitly use a verb like 'returns' or 'provides', and it does not distinguish from sibling tools, but the referent is specific enough.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no guidance on when to use this tool versus alternatives such as titan_get_role_blueprint or titan_get_settings_format. There are no context clues about typical workflows or exclusionary statements.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states that the tool returns a list of topics, which is essentially what the name implies. It does not disclose the return format, whether ordered, pagination, authorization requirements, or any other behavioral trait beyond the basic action.
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 short phrase with no wasted words. It is appropriately brief for a zero-parameter tool, though it could arguably be more structured (e.g., a complete sentence) but this does not detract significantly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description should at least explain what the return value contains. It does say 'list of topics', which gives a general idea, but it does not specify whether the list contains just titles, identifiers, or additional metadata. It is a minimum viable description but lacks detail for an agent to fully anticipate the response.
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, and the input schema is empty with 100% schema description coverage. Since there are no parameters to describe, the description does not need to add parameter-level meaning. The baseline of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Список тем документации Titan SDK.' translates to 'List of topics of Titan SDK documentation.' It clearly indicates the tool lists documentation topics, and this is distinct from sibling tools like titan_get_doc (retrieve a specific doc) and titan_search_docs (search docs). However, it uses a noun phrase rather than an explicit verb, and does not detail the scope (e.g., all topics vs. filtered).
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. It does not mention that users might first list topics before calling get_doc or search_docs, nor does it state any exclusions or prerequisites. The description simply says what it does without context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the disclosure burden. It only says 'full documentation' without explaining return format, errors, or side effects. The example topics add context but do not reveal expected behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence, front-loaded with the purpose. It contains no redundant words and is easy to parse. It could include more detail without becoming verbose, but as is it is appropriately sized.
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 tool has one parameter, no annotations, and no output schema. The description gives minimal information about the tool's behavior, not clarifying what the returned documentation looks like, possible errors, or any prerequisites. Given the lack of structured metadata, the description is insufficient for complete understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has no description for 'topic' (0% coverage). The description compensates by listing example values (aura, spell, player, group…), giving some indication of valid inputs. However, it does not specify an exact enumeration or format, leaving partial ambiguity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (get documentation) and the resource (topic), with examples like aura, spell, player, group. It distinguishes from siblings such as titan_list_docs and titan_search_docs by focusing on retrieving full docs for a specific topic.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: when you need full documentation on a given topic. However, it does not explicitly mention when to prefer this over titan_search_docs or titan_list_docs, and lacks any exclusion criteria or alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral burden. It discloses the file is large (1205 lines) and advises requesting sections, which is useful. However, it doesn't describe side effects, auth requirements, or return format. For a read-only get, this is acceptable but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, packed with relevant info: content type, size, patterns, and parameter tip. No fluff, front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema and no annotations, the description covers what it returns and how to handle the large size. Minor gaps: doesn't specify output format or relationship to sibling 'template' tools, but overall sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single 'section' parameter, which already explains its allowed values and default. The description adds only a generic mention of 'section' without repeating specifics, so it contributes little beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides a full Holy Paladin rotation (1205 lines) as a reference of patterns, naming specific content (settings, enum policies, spender queue, dispel). This distinguishes it from siblings like titan_list_specs or titan_get_template by specifying the exact example content, though it doesn't explicitly contrast with alternatives.
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 explicit guidance on when to use vs alternatives. The description implies use for reference patterns but provides no exclusions or alternative tool mentions, leaving the agent to infer. The section parameter advice is operational, not usage 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?
No annotations are provided, so the description carries the full burden. The word 'search' naturally indicates a read-only operation, but the description does not explicitly state this or disclose any other behavioral aspects (e.g., whether matching is case-sensitive, returns snippets, or has pagination). It provides minimal transparency beyond the obvious non-destructive search action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, complete sentence that is front-loaded with the key verb ('search') and resource. There is no wasted wording, making it highly concise and easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one string parameter, no output schema), a short description is acceptable, but it omits details about what the search returns (e.g., a list of matching documents?) and whether it matches against full text content or just metadata. The absence of an output schema makes these details more pertinent, yet the description leaves them unspecified. It is minimally complete but lacks some expected context.
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%, and the description does not explicitly describe the 'query' parameter. While one can infer that 'query' is the search text from context, the description itself never states this, leaving the agent to rely on the parameter name alone. This is insufficient compensation for the complete lack of schema documentation.
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 specifies a concrete action ('full-text search') on a clear resource ('all SDK documentation'), and the name titan_search_docs reinforces this. It is clearly differentiated from sibling tools like titan_list_docs (which lists docs) and titan_get_doc (which retrieves a specific doc). This leaves 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 usage (when you need to find content within documentation) but gives no explicit guidance on when to use this tool versus alternatives such as titan_list_docs or titan_get_doc. There are no stated exclusions or conditions. The context of sibling tool names helps, but the description itself lacks direct comparison.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of explaining behavior. It describes the content of the blueprint (decision order, API methods, settings, mistakes) and the special role for healers, but does not specify the return format, error behavior, or whether any side effects exist. For a read-only getter, this is acceptable but not fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, with no fluff. The first sentence efficiently lists the main contents; the second adds crucial context for healers. It is well-structured and 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 tool with one parameter and no output schema, the description provides a good overview of what the blueprint contains, including pitfalls and the special SimC APL context for healers. It does not describe the exact output format, but the term 'blueprint' and the content list give enough for an agent to understand the tool's purpose.
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 single parameter 'role' is fully described in the schema (healer/tank/dps), and the description repeats this information. Since schema coverage is 100%, the description adds little beyond reinforcement, but it does mention the allowed values in the opening sentence.
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 that the tool provides a decision-making order for a role (healer/tank/dps), specifying what to check, in what order, which API methods to use, player settings, and typical mistakes. It distinguishes itself from sibling tools by emphasizing it is a functional blueprint, not just a data listing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used when you need decision logic for a role, and for healers it explicitly positions itself as a replacement for the missing SimC APL. However, it does not explicitly state when NOT to use it or name specific alternatives, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. It lists what the code does (healing primitives, targeting policies, dispel) but omits details like return format (e.g., code block), whether it includes dependencies, or compatibility notes. Still, it provides substantive behavioral content.
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 in Russian that efficiently front-loads the purpose ('Ready working Lua code of healing primitives'). It lists contents compactly, though a slight restructure could improve scannability; still, 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?
Given zero parameters and no output schema, the description provides sufficient context about the tool's content and usage. It clearly explains what the code includes and how to apply it, making it complete enough for an AI agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema is trivially covered. Per the rubric, a baseline of 4 applies since there is no parameter semantic burden for the description to address.
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 provides ready-to-use Lua code for healing primitives, enumerating specific features (ally iteration, HP absorption, target selection, tank search, enum policy resolver, dispel). This differentiates it from sibling tools like titan_get_template or titan_get_example, which are more general.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage instruction: 'insert as is and build spec-specific on top, don't rewrite' – establishing when to use it as a base. It does not explicitly name alternatives or exclusions, but the context strongly implies its intended role in healing rotation development.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses important behavioral traits beyond the schema: resolution order (spec spellbook → talent tree → class), unfolding of replacements (Holy Paladin judgment example), and the dependency on spec for correct resolution. Since no annotations are provided, this description carries the full burden of behavioral disclosure, and it does so effectively.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and information-dense. Every sentence serves a purpose: stating the output, providing use case, explaining resolution order with an example, and giving a critical warning about the spec parameter. It is front-loaded with the primary purpose and does not waste words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema and no annotations, the description covers the essential aspects: what it does, how it resolves IDs, and what to watch out for. It lacks explicit return format details, but the return value ('numeric spell IDs') is implied. The warning about spec and the resolution order make it complete enough for an AI to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers 2 of 3 parameters (spec and spells) with descriptions. The description adds extra context: snake_case format like SimC, resolution order, and the criticality of spec. However, the 'class' parameter remains undocumented in both schema and description, and the added information is more about overall behavior than about individual parameter semantics. Thus, it does not fully compensate for the missing class description.
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: converting a list of ability names in snake_case into numeric spell IDs. It specifies the resource (spell names) and the output (IDs), and provides usage context ('Для спеков без APL — основной способ получить ID'). This distinguishes it from sibling tools that might handle rotations or specs data.
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 usage context: it is the primary way to get spell IDs for specs without APL. It also warns that 'spec' must always be passed to avoid resolving to another spec's IDs for multi-spec classes. However, it does not explicitly name alternative tools or state when not to use this tool, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full transparency burden. It discloses what data is returned and conditions it (e.g., SimC APL 'if it exists'), but it does not mention read-only behavior, potential error conditions (e.g., unknown class/spec), output structure, or performance implications of this aggregated call. It is informative but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the key trigger ('CALL THIS FIRST'), followed by a compact list of return contents and the required next step. It is efficient, every sentence earns its place, and there is no fluff or repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Although there is no output schema, the description enumerates the major return components and provides a clear workflow, which covers most of what an agent needs to invoke the tool and proceed. It falls slightly short by not describing the exact structure/field names of the response or handling of invalid inputs, but for an orchestrating starter tool the description is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both `class` and `spec` having descriptive examples in the schema itself. The description adds no additional parameter-level meaning, so the baseline of 3 applies; it simply restates that class and spec 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?
The description explicitly says 'CALL THIS FIRST' for any rotation-creation request and enumerates the exact return payload (identity, role, decision order, spell IDs, SimC APL, module template, settings format). It positions the tool as a comprehensive entry point, distinguishing it from the various sibling data-fetch tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage guidance: call this first for any 'make a rotation for <class> <spec>' request, and then validate via titan_validate_rotation. It implies that using the dedicated getter siblings is unnecessary because this tool returns everything needed in one call, and it names the one required follow-up action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It accurately presents this as a read-only catalog that returns methods with signatures and filters by substring, and adds useful validator context. It does not mention side effects, but none are relevant for a listing 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 compact and front-loaded: the first sentence defines the full scope, and the second gives a practical usage instruction. Every word adds value, with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a low-complexity tool with one optional parameter and no output schema. The description communicates the result type (methods with signatures), the filtering capability, and the intended use case, which is sufficient for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents the single optional 'filter' parameter with description and examples, so the baseline is 3. The tool description only restates the substring filtering concept without adding additional semantic detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool lists all Titan API methods with signatures and supports substring filtering. This distinguishes it from sibling tools like titan_list_specs and titan_list_docs, which cover different resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs the agent to check method names here before using other tools, because invented names will be rejected by the validator. This provides a concrete trigger condition, though it does not name specific sibling alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses the output content (classes, specs, roles, ids) but does not mention any limits (e.g., pagination), performance characteristics, or explicitly confirm read-only behavior. The tool is simple and non-destructive by nature, but the description 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?
The description is two short sentences with no fluff. The first states what the tool provides, and the second gives a concrete usage scenario, making every sentence valuable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema), the description is complete. It explains what is returned (classes and specs with roles and ids) and when to use it (unknown spec names). No further context is necessary for an agent to select and invoke this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description does not need to explain any. The baseline for 0 params is 4, and the description does not contradict this. It correctly implies that no input is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the resource (all supported classes and specs) and the data included (roles and ids), even without an explicit verb. It distinguishes from siblings like titan_get_spec_data (which targets a single spec) and titan_get_role_blueprint (which provides role blueprints) by being the comprehensive listing tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description states a specific use case: 'Useful if the spec name is not recognized.' This provides clear context for when to use the tool, though it doesn't explicitly mention alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden. It discloses an important behavioral trait: for healers, APL is unavailable and returns apl_available=false, with a specific exception. It also discloses the numeric-ID constraint. However, it doesn't explicitly state read-only nature or side effects like caching, but the schema description for resolve_ids does cover the DB2 download.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the main purpose and followed by a crucial caveat. Every clause adds value; no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema, but the description explains what is returned (APL + numeric spell IDs) and key edge cases. It doesn't detail return structure but given the caveats, it is sufficiently complete for an AI agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 33% (only resolve_ids has a description). The main description mentions 'for class/spec' but doesn't provide format or examples for class/spec. It adds context that healers are treated specially, which relates to the spec parameter, but does not fully compensate for the undocumented params.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool returns 'SimC APL (conditional priority) + numeric spell IDs for class/spec', which is a specific verb+resource. It also distinguishes from the sibling titan_get_role_blueprint by noting when APL is unavailable for healers, that alternative should be used.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use guidance: for healers (except druid_restoration), APL doesn't exist and apl_available=false, so 'you need to use titan_get_role_blueprint'. It also states Titan only works with numeric IDs, implying prerequisites. This is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the behavioral transparency burden. It adds significant context by revealing the format is Lua-specific and that official C++ documentation is misleading, implying this tool gives the correct working format. However, it does not explicitly state the return format or side effects, so it stops short of fully disclosing all behavioral traits.
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 adds a critical usage note. It uses all-caps emphasis intentionally for the important instruction without unnecessary verbosity. Every phrase earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity of the tool (no parameters, no output schema), the description provides a reasonably complete picture: what the format is, when to use it, and a caveat about official docs. It would be slightly more complete if it described how the format is presented (e.g., as a string, file, or list), but for a reference tool, the current description suffices.
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, and the schema is empty with 100% coverage. The description does not need to explain parameters but adds value by describing what the returned format includes. This aligns with the baseline of 4 for parameterless tools.
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 identifies the tool as providing the Lua rotation settings format, explicitly listing its contents (bool/int/float/enum, groups, apply). It distinguishes itself from sibling tools by focusing on the format rather than actual rotation data, and crucially contrasts it with the official C++ API documentation, making its unique purpose unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to read this before adding settings ('ОБЯЗАТЕЛЬНО прочитай перед добавлением настроек'), providing a clear when-to-use. It also offers an alternative exclusion by stating that the official documentation is not applicable to Lua, thereby directing users away from it. This is strong usage 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?
With no annotations, the description carries the full behavioral disclosure burden. It reveals key behaviors: what is checked, that role incompleteness is treated as an error rather than a warning, and that failing to pass 'role' disables role checks. It doesn't describe return format or failure modes, but the core behavioral nuances are disclosed for a validation 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 exactly two sentences, front-loaded with the imperative 'ВСЕГДА' (ALWAYS) to emphasize usage. Every clause provides essential information: when to use, what is validated, error severity, and role parameter necessity. No filler or redundant content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a validation tool with a simple schema and no output schema, the description covers the critical contextual aspects: when to call, what is validated, role-specific behavior, and required inputs. It lacks specifics about return values or error reporting, but these are secondary since the agent's primary need is to know when and how to invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for both parameters (lua and role), so baseline is 3. The description adds meaningful context by explaining that passing 'role' enables role-specific completeness checks, which the schema only hints at. This enhances the agent's understanding of how to use the parameter correctly.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: it validates Lua rotation modules by checking syntax, existence of api.*/action.* calls, and role completeness. The verb 'Проверяет' (checks) is specific, and the scope (rotation source code) is clearly defined. This distinguishes it from sibling tools that handle docs, specs, or starting rotations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs the agent to 'ВСЕГДА вызывай перед выдачей финального кода' (ALWAYS call before giving final code), providing a clear when-to-use directive. It also explains the role parameter's necessity for enabling role checks, which is actionable. This is strong usage guidance without needing to reference alternatives.
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:

[![titan-rotation-mcp MCP server](https://glama.ai/mcp/servers/brooke19931993-glitch/titan-rotation-mcp/badges/card.svg)](https://glama.ai/mcp/servers/brooke19931993-glitch/titan-rotation-mcp)

Score Badge

Copy to your README.md:

[![titan-rotation-mcp MCP server](https://glama.ai/mcp/servers/brooke19931993-glitch/titan-rotation-mcp/badges/score.svg)](https://glama.ai/mcp/servers/brooke19931993-glitch/titan-rotation-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/brooke19931993-glitch/titan-rotation-mcp'

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