Clearon Editorial Pipeline MCP

by kwgoodwin

Overview Schema Related Servers Score Discussions

JavaScript

Local

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
Each tool targets a distinct action in the editorial workflow, and the descriptions generally clarify the resource being acted on. The only mild ambiguity is between audit_revision and propose_revision, since both involve style heuristics, but the existing-versus-proposed distinction is made clear.
Naming Consistency5/5
All tool names follow a consistent verb_noun snake_case pattern, such as get_editorial_project, propose_revision, and export_wordpress_payload. There are no mixed conventions or vague generic verbs.
Tool Count5/5
Nine tools is well-scoped for an editorial pipeline covering project creation, inspection, revision workflow, approval, and export. Each tool maps to a meaningful stage in the process without redundancy or bloat.
Completeness4/5
The core lifecycle—create, list, get, audit, propose, apply, approve, and export—is covered with no dead ends. Missing operations like project metadata updates or explicit rejection are minor given the immutable-revision design and the intentional dry-run export boundary.
Average 3.3/5 across 9 of 9 tools scored.
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

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 does disclose one meaningful behavioral trait: the initial revision is immutable. However, it does not mention side effects, validation behavior, uniqueness constraints on slug, permissions, or what the response contains, leaving significant behavioral ambiguity for a mutating tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short and front-loaded, but it is under-specified for a tool with seven parameters and five required fields. Conciseness here results in missing valuable context rather than efficient communication.
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, missing annotations, no output schema, and very low schema description coverage, the description is incomplete. It fails to explain the expected response, how the immutable revision interacts with the revision workflow, or any constraints on the parameters. The single sentence is not enough.
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 only 14%, and the tool description adds essentially no parameter-level meaning. It does not explain required fields like slug, title, content_type, content_format, or content, nor does it mention the optional source_urls and protected_passages. The description makes the schema's job harder rather than easier.
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 ('Create') with a specific resource ('Clearon editorial project') and adds a distinguishing detail ('with an immutable initial revision'). It is immediately clear what this tool does and it stands apart from the sibling get, list, revision, and export tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives no explicit when-to-use guidance, no prerequisites, and no exclusions relative to the revision-focused siblings. The agent must infer that this tool is the entry point for creating a project, but there is no context about when one should choose this over propose_revision or apply_revision.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full behavioral burden. It states the approval action but does not disclose whether approving publishes or finalizes the revision, whether it is reversible, what permissions are required, or what the expected result is. This is a significant transparency gap for a state-changing operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no unnecessary wording. It is concise and the key action is stated immediately, though the terseness sacrifices some behavioral detail that would improve the definition.
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 eight parameters, no annotations, and no output schema, this description is incomplete. It omits the consequences of approval, its relationship to apply_revision, required permissions, and what the agent should expect after a successful call.
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 only adds meaning to the three review-confirmation booleans by framing them as prerequisites. It does not explain the semantics of revision_sha256, slug, revision, approved_by, or note, leaving the agent to infer their roles from names alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the verb 'Approve' and the resource 'current revision', and it adds a specific precondition about review confirmations. It is distinguishable from siblings like propose_revision and apply_revision, though it does not explicitly reference those alternatives.
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 'only after explicit editorial, factual, and quotation review confirmations' provides a clear precondition for when approval is appropriate. However, it does not explicitly state when not to use this tool or mention alternatives such as apply_revision, audit_revision, or propose_revision.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden and does offer some value: 'transparent' signals explainable output rather than a black box, and the negation clarifies a non-behavior. However, it never states whether the tool is read-only or has side effects, nor what the audit returns — significant gaps given siblings like apply_revision are mutations.
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, zero filler, and the primary action is front-loaded ahead of the clarifying negation. Every sentence earns its place; this is efficient, appropriately sized text.
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 annotations and no output schema, the description should cover what the audit produces and confirm non-destructive behavior, but neither is addressed. The required parameter slug and usage context are also missing, leaving an agent under-equipped despite the simple 2-parameter surface.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, but it only echoes the word 'revision' and never explains the required 'slug' parameter or the relationship between slug and revision number. An agent gets no help understanding that slug likely identifies the editorial project scoping the revision.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Run') and resource ('a revision'), and clarifies scope with 'This is not an AI-authorship detector,' which helps an agent distinguish it from a potential misuse. However, 'Clearon style heuristics' is unexplained jargon that weakens clarity, and no sibling tool is named for differentiation.
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 only usage hint is the negative statement 'This is not an AI-authorship detector,' which tells the agent what not to use it for but not when to use it. There is no guidance on workflow placement (e.g., audit before approve_revision) and no alternatives named among the eight 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?
With no annotations, the description carries the full burden of behavioral disclosure. It does convey that this is a non-mutating read and that it returns either the current or a specified immutable revision. However, it does not explain error behavior, permissions, or the practical meaning of 'immutable revision', leaving notable gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no filler and front-loads the core read action before elaborating on revision selection. It is compact and every word contributes, though the phrasing is slightly dense.
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 tool is low complexity, but with no annotations and no output schema, the description is the only source of behavioral and return context. It covers what is read and how revision selection works, but omits when to use the tool relative to siblings and does not address edge cases or failure modes. It is adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It adds useful meaning to the revision parameter by explaining it can be a specified immutable revision or omitted for the current one. However, it does not explicitly clarify that slug identifies the project or describe expected value formats, leaving part of the burden unmet.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Read' and names the resource: project metadata and a revision. This clearly identifies it as a read operation for a single editorial project, distinct from list_editorial_projects and from mutating revision tools like propose_revision or apply_revision, though it does not explicitly name 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?
There is no guidance on when to use this tool versus alternatives. The description only states what it reads; it does not say to prefer this over audit_revision or list_editorial_projects, nor does it mention any conditions or exclusions. The agent must infer usage entirely from the tool name and sibling context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose the key safety traits: immutability and append-only behavior. However, it omits important behavioral details such as what happens when base_sha256 does not match, whether an audit trail is updated, and whether approval status is independently enforced.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with no filler, front-loading the action and the critical safety property. Every clause adds useful constraint information, making it highly efficient for an agent to parse.
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?
Four required parameters are undocumented, there is no output schema, and no annotations are provided, yet the description does not explain what base_sha256 must reference, how change_summary is used, or what the caller receives on success or failure. The workflow position is hinted at but not connected to approve_revision or audit_revision.
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 names none of the four parameters or their formats. 'Exact proposal review' only hints at base_sha256 semantics, leaving slug, revised_content, and change_summary to be inferred from names alone, which is insufficient for correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a concrete operation—'append an immutable revision'—and adds a clear boundary with 'never overwrites prior text,' so an agent can distinguish it from update/overwrite tools. It does not fully explain what constitutes a 'revision' or which sibling produces the exact proposal, but the core purpose is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'after an exact proposal review' states a clear precondition and workflow context, suggesting this is not a first-step tool. It does not explicitly name sibling alternatives or give a when-not-to-use condition, but the intended placement in the revision workflow is reasonably clear.
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 of behavioral disclosure. It implies a read-only operation via 'List' and mentions the returned 'workflow status', which is useful context. However, it does not disclose pagination, ordering, scope (all projects vs. scoped), or whether any side effects exist. For a simple no-parameter list, this is minimally adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no filler. It efficiently communicates both the resource and the key output attribute without wasting words.
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 purpose but leaves several details unspecified: it does not state whether all projects are returned, whether results are ordered or paginated, or what the exact response structure looks like. Given there is no output schema or annotations, more context would be valuable, but for a trivial no-parameter list tool the description is acceptable.
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 input schema is empty ({}), meaning there are no parameters to document. The baseline for 0 parameters is 4, and the description includes no misleading or contradictory parameter information.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('List') and clearly identifies the resource ('editorial projects') and an attribute of interest ('workflow status'). This clearly distinguishes the tool from the singular get_editorial_project, though it does not explicitly name sibling 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 guidance is given about when to use this tool versus the sibling tools (e.g., get_editorial_project or create_editorial_project). There is no mention of prerequisites, exclusions, or scenarios where a different tool would be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full disclosure responsibility. It usefully reveals that the tool does not publish and produces only a draft-only payload, which signals a non-destructive core behavior. However, it does not mention side effects, prerequisites like needing an approved revision, whether it persists anything, or what happens if no approved revision exists.
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 filler. It front-loads the core action and purpose, then adds a crucial clarifying negation. Every word contributes value.
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 six parameters, no output schema, no annotations, and low schema coverage, the description is too thin. It conveys the overall workflow intent but omits parameter semantics, return value, failure modes, and the relationship between the payload and the WordPress publishing dry run. An agent cannot confidently invoke this tool correctly with only the provided information.
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 only 17%, and the description adds no parameter-level meaning whatsoever. It does not explain slug, tags, excerpt, categories, local_featured_image, or even the critical trusted_html flag beyond what the schema already says. An agent would have to guess the meaning of five of the six 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 states a specific verb and resource: "Create a draft-only payload from the approved revision" for a "separate publishing dry run." The explicit negation "Does not publish" sharply distinguishes it from any direct publishing flow, and referencing the approved revision links it clearly to the revision workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly identifies the context: creating a draft-only payload for a separate dry run after an approval. It also communicates a key exclusion by stating it does not publish, which prevents use as a publishing action. It does not name sibling tools explicitly, but the intent and boundary are 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, the description must signal safety/behavior itself; 'Report' does imply a non-mutating read operation. However, it does not disclose any operational caveats such as authentication, freshness of data, or failure behavior, and the three reported items are stated without elaboration.
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 short sentence with no filler and leads with the operation verb. Every phrase ('health', 'storage root', 'review boundary') contributes useful specificity.
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 trivial no-argument tool, invocation is clear, but there is no output schema and the description only names the three report areas without explaining their shape or meaning. An agent knows roughly what it will get but not enough to interpret the response fully.
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 fully covers everything; the baseline for 0-parameter tools is 4. No additional parameter meaning is needed, and the description's three report categories are output context, not parameter semantics.
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 ('Report') with a clear resource and three concrete aspects (editorial pipeline health, storage root, review boundary). It is easily distinguished from sibling tools, which are about editorial projects/revisions and WordPress export rather than server health.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to call this tool versus the sibling inspection tools such as get_editorial_project or audit_revision. The tool's purpose implies a health-check usage, but the description does not state conditions, alternatives, or exclusions.
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 safety burden; it explicitly discloses that the revision is not saved and details three validation checks (fingerprint, protected passages, style heuristics). It does not mention error behavior or return format, but the side-effect profile is clearly 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?
One front-loaded sentence communicates purpose, side-effect, and validation criteria with no filler. The semicolon cleanly separates the primary action from the behavioral details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations and no output schema, the description covers purpose and behavior but leaves return shape, failure modes, and exact parameter requirements unstated. This is adequate but has clear 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?
Schema descriptions are absent (0% coverage), but the description maps 'current fingerprint' to base_sha256 and 'proposed rewrite' to revised_content, giving useful context. It does not explain slug or optional change_summary, and it omits format/constraint details, so the compensation is partial.
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 ('validate') and identifies the resource ('proposed rewrite'), explicitly noting it does not save. The phrase 'checks the current fingerprint, protected passages, and style heuristics' adds concrete scope that distinguishes it from sibling apply/approve tools.
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?
'Without saving it' clearly frames the tool as a dry-run validation step, so an agent can infer using it before apply_revision/approve_revision. It does not explicitly name alternatives or exclusions, but the context is clear enough relative to the sibling names.
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

clearon-editorial-pipeline-mcp MCP server

Copy to your README.md:

[![clearon-editorial-pipeline-mcp MCP server](https://glama.ai/mcp/servers/kwgoodwin/clearon-editorial-pipeline-mcp/badges/card.svg)](https://glama.ai/mcp/servers/kwgoodwin/clearon-editorial-pipeline-mcp)

Score Badge

Copy to your README.md:

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

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