TypeWriter MCP

Server Quality Checklist

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

Latest release: v2.0.0
Disambiguation5/5
Each tool targets a distinct resource and action: pages vs entries vs connection vs publish. Update_entry and replace_entry are clearly differentiated by scope (field-level vs whole object). Even connect_live and connection_status are distinct (action vs status check).
Naming Consistency4/5
Most tools follow verb_noun snake_case (list_pages, create_page, add_entry, delete_entry). Minor deviations: 'connection_status' (noun phrase), 'connect_live' (verb+adverb), and 'publish' (single verb) break the pattern slightly, but the style remains consistent and readable.
Tool Count5/5
15 tools provide a well-scoped set covering connection, page management, entry management, story wiring, search, validation, and publishing. No redundancy or bloat; each tool serves a clear purpose in the narrative authoring workflow.
Completeness4/5
The surface covers the full lifecycle for pages and entries, plus important cross-cutting concerns (search, validation, publish). Minor gaps exist (no update_page for metadata, no remove_trigger operation), but agents can work around these using existing tools without major friction.
Average 3.6/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
- 2 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 provided, the description carries the full burden of behavioral disclosure. It only states the basic action (rename), but omits any effects such as whether the old name becomes obsolete, whether links break, whether permissions are required, or whether the operation is reversible. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single short sentence with no wasted words, which is efficient and front-loaded. However, it is under-specified, as it omits crucial behavioral and parameter information, so it is concise but not optimally informative.
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 is simple with only two parameters, but the description is too minimal. There is no output schema, no annotations, and no mention of return values, side effects, or parameter semantics. For a mutation tool, this is not complete enough for an agent to invoke it confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description adds no information about the parameters 'page' and 'newName'. It does not clarify what format 'page' should take (ID, path, title) or any constraints on 'newName'. With no schema descriptions and no explanation in the tool description, parameters are effectively undocumented.
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 'Rename a page' uses a specific verb and resource, clearly distinguishing this tool from sibling tools like create_page, read_page, and delete_page. It directly communicates the action and target.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, such as update_entry or replace_entry. There is no mention of prerequisites, context, or exclusions, leaving the agent to infer usage entirely 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description must disclose behavioral traits on its own. It only states 'delete,' which implies destructiveness, but doesn't clarify permanence, cascading effects, or prerequisites. The agent is left without information about what happens to related data or whether confirmation is needed.
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 redundant words. It states the action and the key identifier efficiently, earning its place despite being minimal.
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 two required parameters, no output schema, and no annotations, the description is insufficient. It fails to explain the 'page' parameter, the behavior on deletion, or any side effects. The tool is simple but still incomplete for safe and correct usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain the parameters. It only hints at entryId via 'by id,' but completely ignores the required 'page' parameter. An agent would not understand the role of 'page' or how it interacts with entryId, making it impossible to invoke the tool 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 verb (delete), the resource (entry), and the identification method (by id). It effectively distinguishes from sibling tools like delete_page and update_entry, making its purpose specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention that it's for removing an entry from a page, nor does it clarify relationships with sibling tools like delete_page or add_entry. There are no usage contexts or exclusions.
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 provided, the description carries the full burden of behavioral disclosure. It only states that the tool creates a page and lists types, but gives no details about side effects, required permissions, uniqueness constraints, or what happens on creation (e.g., persistence, validation, default values). This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise, using two short sentences to convey purpose and type options. There is no filler or redundant information, and the key action is front-loaded in the first sentence.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 4 parameters, 2 required, no output schema, and no annotations, the description is insufficient. It does not explain return values, error conditions, constraints (e.g., uniqueness of name), or how the page types differ. The description is minimally viable but clearly incomplete for a complex create operation with multiple optional fields.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate by explaining parameters. It only repeats the enum values for 'type' (already present in the schema) and does not explain the meaning of 'name', 'chapter', or 'priority'. The description adds minimal value beyond the schema's structural definitions.
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 action with a specific verb and resource: 'Create a new page.' It additionally lists the valid page types (sequence, static, cinematic, manifest), which distinguishes it from sibling tools like list_pages, read_page, rename_page, and delete_page. This is a clear, non-tautological purpose statement.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention when to prefer create_page over other page-manipulation tools like rename_page or delete_page, nor does it explain when each page type would be appropriate. The only contextual hint is the list of types, but this is more about parameter selection than usage 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states that the tool 'connects' but does not mention side effects, whether the connection is persistent, authentication requirements, error behavior, or how to terminate the connection. The presence of a forceReconnect parameter hints at reconnection behavior, but the description does not explain it. Significant behavioral context is missing.
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, well-structured sentence that immediately states the core action and provides the necessary context for the URL. There is no fluff or redundancy; every word contributes to understanding the tool's essential 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?
Given the tool's complexity (a websocket connection) and the lack of output schema or annotations, the description is too brief. It does not explain the expected result of connecting, how the connection behaves, what forceReconnect does, or how this relates to connection_status. The description covers only the initial step of obtaining the URL, leaving significant gaps for an agent to invoke and interpret the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for explaining the parameters. It partially does for 'url' by referencing the '/typewriter connect' command, but it completely omits 'forceReconnect'. The boolean semantics of forceReconnect (e.g., whether it forces a new connection over an existing one) are left entirely to the parameter name, which is insufficient for a tool with zero schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Connect to a live Typewriter websocket.' It specifies the action (connect), the resource (live Typewriter websocket), and even provides a source for the URL ('from /typewriter connect'). This distinguishes it from sibling tools like connection_status, which likely checks the status rather than establishing a connection.
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 a live websocket connection is needed, and it indicates the URL must come from '/typewriter connect'. However, it does not explicitly contrast it with alternatives like connection_status, nor does it state when not to use it. The guidance is present but not fully explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It mentions the id constraint but fails to state whether the entry must exist, what happens to tied relationships, or any side effects. Minimal behavioral context for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the essential action and constraint with zero wasted words. Ideal conciseness.
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 no annotations, no output schema, and a nested object parameter, the description is too brief. It omits likely-needed context like return values, error behavior if the id doesn't exist, and whether the page must exist. Significant gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds context about the entry (must keep same id) but does not explain the 'page' parameter or the structure/required fields of the entry object. Only partial compensation.
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 ('Replace'), the resource ('a whole entry'), and the key requirement ('must keep the same id'). This distinguishes it from sibling tools like update_entry (partial updates) and add_entry (new entries).
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 'replace a whole entry' implies this is for full replacement rather than partial field updates, but it does not explicitly mention alternatives or when to prefer this over update_entry. Usage context is implied, not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must disclose behavioral traits. It does reveal a key destructive side effect: deleting a page also deletes all its entries. However, it lacks any mention of irreversibility, permissions, or what happens to linked data, leaving significant behavioral gaps for a destructive operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that conveys the essential action and its primary consequence. Every word is meaningful, with no filler 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?
For a simple destructive tool with one parameter and no output schema, the description is adequate but incomplete. It lacks context such as permanence, required permissions, or what qualifies as a 'page'. Given the destructive nature, a stronger warning or precondition would improve completeness, but the cascade note mitigates some ambiguity.
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 schema has one parameter ('page') with 0% description coverage, so the description must compensate. It mentions 'a page' but does not clarify the expected format (e.g., ID, name, path) or relationship to the parameter. The parameter name alone is insufficient, and the description adds little semantic value beyond restating the resource.
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 'Delete a page and all its entries' uses a specific verb ('delete') and resource ('page') while explicitly noting the cascading effect on entries. This distinguishes it clearly from sibling tools like delete_entry, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives (e.g., delete_entry for entries only). It does not state prerequisites, alternatives, or situations where it should be avoided, offering only the basic action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It mentions the scope ('across all pages/entries') but does not disclose any other behavioral traits such as return format, pagination, case sensitivity, or read-only nature. Minimal additional context beyond the basic function.
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 with no redundant phrasing. Every word contributes to the purpose and scope.
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 no output schema and no annotations, so the description must explain what the search returns. It does not mention result format, whether it returns entries, pages, or both, or any limitations. While the scope is clear, the description is incomplete for a tool that returns search results.
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 0%, so the description must compensate. The phrase 'Full-text search' implies that the 'query' parameter is the search text, adding some meaning beyond the empty schema description. However, it does not specify any format, wildcards, or options, so it only partially compensates.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Full-text search') and the resource ('across all pages/entries'), making it distinct from sibling tools like list_pages or add_entry. The scope is explicit and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage when a full-text search across pages/entries is needed, but it does not explicitly mention when to use this tool over alternatives such as list_pages or read_page. No exclusions or alternative comparisons are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden of behavioral disclosure. It describes the action and path format but does not explain overwriting behavior, handling of non-existent paths, value type constraints, or return values. This is a significant gap for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with an illustrative example, which is efficient and front-loaded. It avoids unnecessary verbosity while still conveying the core mechanism.
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?
As a mutation tool with no annotations and no output schema, the description is incomplete for safe use. It lacks details about errors, edge cases, or what the update does if the path is invalid, making it insufficient for an agent to invoke with full confidence.
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 meaning to the 'path' parameter with examples like 'criteria.0.value', clarifying dotted-path syntax. However, it provides no semantics for 'page', 'entryId', or 'value', and the schema itself has zero descriptions, leaving most parameters under-specified.
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 the specific verb 'update' and resource 'entry' with scope 'single field' and 'dotted path', clearly distinguishing it from siblings like replace_entry and add_entry. This makes the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'single field' implies partial modification, suggesting when to use this tool over replace_entry (which likely replaces the whole entry). However, it does not explicitly name alternatives or provide exclusionary conditions, so it falls short of full guidance.
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 provided, the description carries the full burden of behavioral disclosure. It states that it 'finds' broken references, but does not specify whether it is read-only, what it returns (e.g., a list, summary, errors), or whether it modifies anything. This is a significant gap 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 a single, concise sentence that gets straight to the point. There is no waste or redundancy, and it efficiently communicates the core 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?
Given there is no output schema, the description should explain what the tool returns or how the results are presented. It does not mention the output format, error handling, or any limitations. This makes it incomplete for an agent trying to use the tool effectively.
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. Per the baseline for 0-param tools, the description does not need to add parameter details. It provides a clear description of what is validated, which is sufficient.
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: finding broken references in storylines (triggers/triggeredBy pointing to missing ids). It uses a specific verb ('find') and a specific resource ('broken references'), making it distinct from sibling tools like connect_entries or connection_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or use cases. It simply states what it does, leaving the agent to infer when validation might be needed.
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 transparency burden. It clearly discloses the mutation behavior (appending to a list), which is the core side effect. However, it does not discuss error cases, permissions, or whether the operation is reversible, but for a simple append the main behavior is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the purpose and mechanism. Every word earns its place, with no redundant content or verbose explanation.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core operation but omits critical context: the role of fromPage, expected outcomes, and potential errors. Given the tool's simplicity and no output schema, the description is partially complete but insufficient for fully correct invocation without additional inference.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains the roles of fromEntryId and toEntryId in the append operation, but the fromPage parameter is completely unaddressed. With 0% schema coverage, the description must compensate for all parameters, and it leaves one unexplained, creating an invocation gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('append') and resource ('triggers' list), clearly identifying the tool's function. It distinguishes from siblings like connect_live by specifying the exact mutation mechanism. The relationship between fromEntryId and toEntryId is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used for wiring story flow, but provides no explicit when-to-use guidance or mention of alternatives like connect_live. There is no comparison to other tools or exclusions, leaving the agent to infer appropriate usage from the 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?
With no annotations, the description carries the burden of disclosing behavior. It adds useful facts: fields must contain 'name' and 'type', and 'id' is generated automatically. However, it does not mention permissions, success/error behavior, or any side effects beyond adding an entry. The transparency is partial.
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 core purpose, and the second sentence packs essential parameter details and common types without waste. Every word earns its place; no filler or repetition of the name/title.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter tool with one complex object, the description covers the critical details needed to construct a valid request: the fields parameter structure and supported types. However, it is quiet on return value/response and page reference ambiguity, making it slightly incomplete for an agent needing to invoke it correctly in all cases.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain parameters manually. It does well for 'fields' by describing the raw JSON format, required keys, and auto-generated 'id'. However, 'page' is left as a bare string with no explanation of whether it expects a page name or ID, a notable under-specification for one of two parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Add') and resource ('an entry to a page'). It distinguishes itself from sibling tools like update_entry, replace_entry, and delete_entry by explicitly being the 'add' operation, with no ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is used to create new entries on a page, and the list of common types suggests appropriate use cases. However, it does not explicitly say when to avoid this tool (e.g., for updates use update_entry) or name any alternatives. This is a clear gap for a tool with related siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the output fields and implies a read-only operation via 'list', but lacks details on pagination, ordering, or potential side effects. For a simple listing tool, this is adequate 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?
The description is a single concise sentence, front-loaded with the action and resource, and includes a parenthetical list of return fields. There is no wasted wording.
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 parameterless list tool, the description covers the core function and output. It does not mention prerequisites like connection status or pagination, but these are not critical for a simple listing operation. Overall sufficiently complete for its simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is empty. The description does not need to explain parameters. A baseline of 4 is appropriate since there is nothing to add.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists all pages and specifies the returned fields (name, id, type, entry count). This distinguishes it from sibling tools like read_page (single page) and create_page/delete_page (mutations).
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 'List all pages' implies when to use it, but there is no explicit guidance about alternatives or when not to use it. It does not mention that read_page should be used for a single page, so usage is only implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses that edits are applied live in-game, indicating a production-mutating action. However, it does not mention reversibility, side effects, or whether confirmations are involved, leaving some behavioral ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no fluff. The parenthetical adds essential context without bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with no output schema, the description covers the core purpose and immediate effect. It could mention irreversibility or a validation prerequisite, but overall it is reasonably complete given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so parameter semantics are not applicable. Baseline is 4, and the description adds no parameter info, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Publish' and identifies the resource 'staging changes to production' with a clarifying effect 'applies edits live in-game'. This clearly distinguishes it from sibling CRUD operations like create_page or update_entry.
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 that the tool is used when staging changes are ready to go live, but it does not explicitly state prerequisites or contrast with alternatives like validate_storyline. There is no explicit 'when to use' or 'when not to use' 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?
No annotations are provided, so the description must convey behavioral traits. It states the tool shows status information, implying read-only behavior, but does not explicitly confirm no side effects or describe what the output looks like. This is a minor gap for a simple status tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, focused sentence that directly states the tool's purpose without extraneous information. Every word earns its place.
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 (no parameters, no annotations, no output schema), the description adequately covers what the tool does: it reports connection status and whether a saved URL exists. No additional context is necessary.
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 schema coverage is trivially 100%. Per the rubric, a baseline of 4 is appropriate since there are no parameters needing semantic explanation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Show') and identifies the resource ('Typewriter connection status') plus a secondary condition ('whether a saved connect URL exists'). It is clearly distinct from sibling tools like connect_live, which establishes a connection rather than displaying status.
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 for checking connection status, which is useful before using connect_live or diagnosing issues. It does not explicitly state alternatives or exclusions, but the usage context is clear for a status query.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses that the tool returns the full page (all entries), which is behavioral context beyond the name. However, it omits details about return format, error cases, or pagination, but for a read operation this is a moderate disclosure.
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 essential information without redundancy. Every word adds value, and the structure is easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter read tool, the description is complete: it names the target, explains what is returned (all entries), and the accepted identifier format. No output schema exists, but the description gives enough about the return (all entries) to set expectations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema only provides a string property 'page' with no description (0% coverage). The description adds crucial semantic meaning by specifying that 'page' can be a page name or id, fully compensating for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Read'), identifies the resource ('full page'), and clarifies scope ('all entries') and accepted identifiers ('page name or id'). This clearly distinguishes it from siblings like list_pages or search_entries.
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 phrase 'full page (all entries)' implies the appropriate use case: when you need all entries of a page. However, it does not explicitly mention when to prefer an alternative (e.g., search_entries) or provide exclusions, so it stops short of full guidance.
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:

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

Score Badge

Copy to your README.md:

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

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