BlindWrite MCP

by ygstudio-game

Overview Schema Source Related Servers Score Discussions Admin

TypeScript

Local

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most benchmark tools have clearly distinct resource-action boundaries, but benchmark_compare_models, benchmark_get_model_stats, and benchmark_get_leaderboard all describe performance summaries and could be confused by an agent. benchmark_generate_outputs and writer_generate are somewhat related, though writer_generate is explicitly marked as the primary writing tool.
Naming Consistency4/5
Ten tools consistently follow a benchmark_<verb>_<noun> naming pattern, which is highly predictable. writer_generate breaks the pattern by using noun_verb form and dropping the benchmark_ prefix, making the set slightly inconsistent.
Tool Count5/5
Eleven tools is well-scoped for a blind benchmark workflow plus an integrated writing generation tool. Each tool serves a recognizable step or query in the system, and the count is neither bloated nor thin.
Completeness4/5
The core benchmark lifecycle is covered: create task, generate outputs, start duel, submit vote, get results, and retrieve leaderboards. Obvious gaps include no list/update/delete for tasks and no way to enumerate active duels, but these are workable minor omissions.
Average 3.6/5 across 11 of 11 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- 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?
No annotations are provided, so the description carries the full burden. It identifies the data source ('battle voting history') and analysis dimensions, but fails to disclose whether this is a read-only operation, what aggregation or statistical methods are used, what output format to expect, or any side effects. The agent is left guessing about core runtime behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence that conveys the core function without filler. It clearly states the verb, object, and key dimensions, making it easy to scan and parse. No wasted words.
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?
There is no output schema, yet the description does not describe the return value at all. It also omits details like how preferences are quantified, what the output structure is, and how the two optional parameters alter behavior. For an analysis tool, this is a significant completeness gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents 'category' and 'min_votes'. The description adds no extra meaning beyond what the schema provides, such as how the category filter interacts with preferences or what min_votes affects. Baseline 3 is appropriate given the full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Analyze') and names a distinct resource: 'empirical user preference patterns (conciseness, structure, tone) from battle voting history.' This clearly differentiates it from sibling tools like benchmark_get_results, benchmark_get_leaderboard, and benchmark_compare_models.
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 states what the tool does but gives no guidance on when to choose it over alternatives. It does not mention exclusions, prerequisites, or which sibling tools to use for other analysis purposes. The intended context is implied but not explicitly spelled out.
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 behavioral disclosure burden. It does mention listing and pricing, but it says 'all' models while the enabled_only parameter defaults to true, meaning the default call returns only enabled models. This is misleading and omits the filtering behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the tool's basic function.
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 tool with no output schema, the description should clarify what fields are returned and how filters affect results. It does not mention the category filter, the enabled_only default, or the exact response shape, and the 'all' wording conflicts with the default 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?
Schema description coverage is 100%, so both parameters are already documented in the input schema. The description adds no additional parameter meaning, but with full schema coverage the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action and resource: listing AI writing models from the benchmark registry with pricing information. This distinguishes it from sibling tools like benchmark_compare_models or benchmark_get_leaderboard, which serve different purposes.
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, nor does it mention any exclusions or preferred contexts. It only states the action, leaving the agent to infer when a plain list is the right choice.
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 behavioral disclosure burden. It does disclose a nontrivial behavior: setting reveal to true unmask model identities and end the blind stage. However, it does not explain whether this is reversible or what side effects 'ending the blind stage' has beyond unmasking.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. It front-loads the primary purpose and then adds the key behavioral caveat about reveal, making it easy to scan and understand.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with fully documented parameters, the description is mostly adequate. However, there is no output schema, and the description does not describe what the returned benchmark results contain or how the blind stage context affects them, leaving some ambiguity about expected output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both task_id and reveal. The description slightly reinforces the reveal semantic by restating the unmasking behavior, but it adds no new parameter meaning beyond what the 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 clearly states the action ('Retrieve') and the resource ('benchmark results for a task'), making the core purpose obvious. It does not explicitly differentiate from sibling tools like benchmark_get_leaderboard or benchmark_get_model_stats, but the task-scoped phrasing provides enough distinctiveness.
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 choose this tool over sibling alternatives such as benchmark_compare_models or benchmark_get_leaderboard. The only usage hint is the reveal behavior, which addresses a parameter rather than tool selection context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral disclosure burden. It does suggest a read-only, historical operation via 'accumulated pairwise benchmark battle history', but it does not disclose return format, edge cases, rate limits, permissions, or whether any state is changed.
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. Every word contributes meaning, and the core action and data source are front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description leaves important context unstated: what the returned comparison looks like, how category filtering behaves, and what happens when no battle history exists. It is enough for basic invocation but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so all three parameters are already documented in the schema. The description adds no new parameter-specific semantics beyond implying model_a_id and model_b_id are the two compared models, which is baseline value.
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 ('Compare') and resource ('two AI models head-to-head'), and adds meaningful scope ('using accumulated pairwise benchmark battle history'). This clearly differentiates it from sibling tools like benchmark_get_leaderboard or benchmark_get_model_stats.
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 it: when a direct head-to-head comparison of two models from prior duel history is needed. However, it does not explicitly state alternatives, exclusions, or when a different tool such as benchmark_start_duel or benchmark_get_leaderboard would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose meaningful behavioral traits: randomization, blind evaluation, and masked model identities. However, it doesn't explain side effects, what the call returns, whether execution is asynchronous, or what happens when no output IDs are provided.
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, both informative and non-wasteful. The core action is front-loaded and the key detail about hidden model identities comes immediately after, with no redundant material.
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?
Despite a clear one-line purpose, the description is incomplete for a mutation-like state-changing tool. It doesn't state what the response contains, whether output IDs must come from a prior step, or how the duel flows into sibling voting/result tools. No annotations or output schema compensate for these gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents all three parameters with 100% coverage, so the baseline is appropriate. The description adds no new parameter-level detail beyond implying that two outputs are involved; the optional output IDs and task_id semantics are left to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific action ('Start'), a specific resource ('a randomized, blind A/B battle'), and the evaluation purpose. It also distinguishes the tool from siblings like benchmark_compare_models and benchmark_submit_vote by emphasizing that it initiates a battle rather than analyzing, voting, or retrieving results.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given about when to use this tool versus the many benchmark siblings. It doesn't mention prerequisites, how it relates to benchmark_generate_outputs or benchmark_submit_vote, or when an agent should choose it over benchmark_compare_models.
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 explain side effects itself, but it only says 'Create' without disclosing persistence, authentication needs, rate limits, or what the response contains. The blind benchmark context is mentioned, but no behavioral detail about the created resource or follow-up actions is provided.
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?
One dense sentence front-loads the action and resource, then lists the key fields in a natural order. There is no redundant wording or fluff.
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 fully described 6-parameter schema, an agent can probably invoke the tool correctly. Yet the absence of annotations and an output schema, combined with no mention of what the create operation returns or how the task relates to the other benchmark workflows, leaves a modest but not critical context gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so every parameter already has a description. The tool description adds only slight reinforcement for category, prompt, and evaluation_criteria; it does not add meaning for title, user_id, or difficulty. Baseline 3 is appropriate because the schema carries the semantic load.
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 the exact verb ('Create'), the resource ('a new blind AI writing benchmark task'), and the core content fields ('category, prompt, and optional evaluation criteria'). It clearly differentiates from sibling tools such as benchmark_compare_models, benchmark_get_results, and writer_generate, which cover comparing, retrieving, or writing rather than creating tasks.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the verb: call this when creating a new benchmark task. However, the description does not state when to prefer this over related alternatives, nor does it mention any exclusions or prerequisites (e.g., whether a user must exist beforehand).
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 behavioral disclosure burden. It communicates a read-only intent through 'Get' and enumerates the returned information categories, but it does not describe aggregation details, data freshness, or error/edge-case behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
One concise, front-loaded sentence with no filler or redundancy. Every word adds information relevant to selecting or invoking the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter, no-output-schema tool, the description provides essential context: what is returned and the target model. Some detail about the exact response shape is missing, but the tool's simplicity makes the description reasonably 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?
The input schema already documents model_id with 100% coverage, so the baseline of 3 applies. The description does not add new parameter details, but 'for a specific model' aligns naturally with the single required parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that this tool gets performance metrics, win rates, and ranking score for a specific model. It differentiates from leaderboard/comparison tools by scoping to a single model, though it does not explicitly name siblings.
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 intended use is implied: inspect statistics for one model. However, there is no explicit guidance on when to prefer this over benchmark_compare_models, benchmark_get_leaderboard, or benchmark_get_results, and no exclusions or prerequisites are given.
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 of behavioral disclosure. It does reveal a meaningful behavior: models remain strictly anonymous, and it names the OpenRouter dependency. However, it does not disclose side effects such as whether outputs are persisted, whether generation is costly or slow, or what the caller receives back.
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 carry the entire definition, with the main action front-loaded and the key anonymity constraint in the second sentence. There is no filler, redundancy, or unnecessary detail.
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 definition is adequate for a three-parameter tool, but with no output schema it leaves several gaps: no return-value description, no prerequisites such as the benchmark task needing to exist, and no statement about whether outputs are stored or only returned. Sibling relationships and alternatives are also not addressed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents all 100% of the parameters, including defaults and constraints. The description adds no parameter-level meaning beyond the schema, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (Generate), the resource (writing outputs for a benchmark task), and the mechanism (across competing models via OpenRouter). It also adds the distinctive guarantee that models remain anonymous, which helps separate it from general writer_generate and other benchmark workflow tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'for a benchmark task across competing models' implies when the tool should be used, but there is no explicit guidance about when not to use it or which sibling tool should be preferred instead. It does not reference benchmark_start_duel, writer_generate, or any alternative.
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 behavioral disclosure burden. It discloses the ranking methodology (Bradley-Terry and Elo), which is useful, and 'Get' implies a read operation. However, it does not state whether authentication is needed for 'personal' scope, what the response format is, or whether any side effects occur.
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 wasted words. It states the action and key scoping information immediately and remains focused on what the tool does.
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 is adequate for a straightforward leaderboard retrieval tool, but it lacks context about return values, default metrics, and whether 'personal' requires caller identity. With no output schema and no annotations, the agent must infer several important details from the parameter defaults and examples.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already documented. The description adds semantic context for 'scope' and 'metric' by mentioning personal/global and Bradley-Terry/Elo, but it does not add meaning for 'category' or 'min_battles'. This matches the baseline of 3 for full schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') and resource ('personal or global model rankings'), making the tool's purpose immediately clear. It also distinguishes itself from siblings like benchmark_get_model_stats and benchmark_compare_models by focusing on leaderboard rankings rather than stats or comparisons.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool should be used when the agent needs leaderboard rankings, but it provides no explicit when-to-use guidance or alternatives. There is no mention of when to prefer this over benchmark_get_model_stats or benchmark_compare_models, leaving the choice mostly to inference from the tool name.
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 discloses the blind nature of the vote and optional fields, but it does not mention any side effects such as whether votes are updatable, idempotent, or require authentication. Since no annotations are provided, this is acceptable but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, with two sentences that cover the essential action and optional parameters without unnecessary detail or 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?
The description provides sufficient context for the tool's purpose and parameters, but it does not specify the response format or any post-submission behavior. Given the lack of an output schema, this is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already fully describes all parameters, and the description repeats the same information without adding new semantic nuances (e.g., the meaning of 'dimension_scores' or constraints beyond the schema). It meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: submitting a blind preference vote with a specific set of choices (A, B, or tie) and optional reasoning/ratings. It is distinct from sibling tools that compare, analyze, or generate results.
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 by its action-oriented wording, but it does not explicitly state when to prefer this tool over alternatives or provide context about prerequisites (e.g., needing a valid battle_id from a duel).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden, and it discloses the most non-obvious trait: output is generated by external OpenRouter models rather than Claude, with automatic model selection from the user's leaderboard or a cost-effective default. It does not cover failure modes, costs, rate limits, or latency of the external dependency, which are the remaining gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences with no waste: the purpose and trigger are front-loaded in sentence one, the workflow in sentence two, and the model-selection behavior in sentence three. Each sentence adds distinct, necessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters and no output schema, the description covers the essentials: when to trigger it, what workflow to follow before calling, and which models will execute generation. The gaps — unspecified return format and no guidance on external-service unavailability — are modest and do not block correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3; the schema already documents prompt, category, model_id, max_tokens, temperature, and system_prompt with defaults and examples. The description adds only marginal framing around the leaderboard-based model selection, which largely restates what the schema says about category and model_id defaults.
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 'PRIMARY WRITING TOOL' and states a specific verb+resource: write, draft, or compose content, with enumerated types (emails, articles, proposals, essays, sales copy, social posts). It also discloses the core mechanism — delegation to OpenRouter models — which clearly distinguishes it from the benchmark_* sibling 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?
Explicitly states when to use: 'Use this tool whenever the user asks to write, draft, or compose content.' It also defines the exact workflow — outline strategy first, then delegate generation to OpenRouter rather than spending Claude output tokens — and implies the exclusion of direct long-form generation with Claude. No writing alternative exists among the siblings, so no other routing is needed.
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:

[![BlindWrite MCP MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/ygstudio-game/BlindWrite_MCP/badges/card.svg)](https://glama.ai/mcp/servers/ygstudio-game/BlindWrite_MCP)

Score Badge

Copy to your README.md:

[![BlindWrite MCP MCP server – quality and maintenance score on Glama](https://glama.ai/mcp/servers/ygstudio-game/BlindWrite_MCP/badges/score.svg)](https://glama.ai/mcp/servers/ygstudio-game/BlindWrite_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/ygstudio-game/BlindWrite_MCP'

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