splicedeck

by ihuzaifashoukat

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

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

Latest release: v0.0.0
Disambiguation4/5
Most tools have clearly distinct purposes (e.g., inspect reads media, draft starts a cut sheet, splice adds segments, hear transcribes). A few pairs like 'splice' and 'place' could be confused in the abstract, but descriptions differentiate them. Overall, an agent can reliably distinguish tools.
Naming Consistency5/5
All tool names are single-word verbs in lowercase, following a highly consistent pattern. Names like 'splice', 'carve', and 'trial' are domain-appropriate and uniform, with no mixing of conventions.
Tool Count5/5
18 tools cover a comprehensive media editing workflow—ingest, editing, verification, delivery, and auxiliary operations. The count feels well-scoped for the domain, with each tool serving a necessary function and no redundancy.
Completeness4/5
The toolset covers the core editing lifecycle well (from source intake to final delivery). Minor gaps exist, such as a lack of tools for deleting segments, managing sources, or listing projects, but these are not critical to the main editing flow.
Average 3/5 across 18 of 18 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 3 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
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 bears full responsibility for behavioral disclosure. It merely says 'search and record rights' without detailing side effects (e.g., that acquire downloads and creates a record, or that the tool is idempotent via the 'key' parameter). The schema descriptions fill some gaps, but the tool description itself lacks essential behavioral context.
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 of 14 words. It is concise and efficient, but it sacrifices precision and completeness for brevity. It could be slightly improved without losing conciseness, but it is not verbose.
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 (7 parameters, no output schema, no annotations), the description is too sparse. It fails to explain the search-then-acquire workflow, the role of the idempotency key, or the meaning of the 'refresh' and 'seconds_min' parameters. The description is inadequate for correctly invoking the tool in all scenarios.
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% (all 7 parameters have descriptions). The tool description adds minimal additional meaning beyond the schema – it maps 'search' to 'terms' and 'record rights' to 'acquire', but does not clarify other parameters like 'refresh', 'seconds_min', or 'kind'. Baseline 3 is appropriate given high schema coverage and limited added value from the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Search licensed third-party music and hits, and record the rights for one that fits.' It identifies a verb+resource but is partially inaccurate: the schema allows searching footage, stills, and typefaces in addition to music and hits. The purpose is vaguely clear but not fully aligned with the tool's capabilities.
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 use this tool versus its many siblings (e.g., inspect, hear, preview). There is no mention of prerequisites, alternatives, or when not to use it. The description implies a search-and-acquire workflow but offers no explicit selection criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral transparency. The description implies a state change ('start a new cut sheet'), but it doesn't disclose what this operation does beyond creation (e.g., does it write files? interact with an API? trigger a workflow?). It doesn't mention destructive potential or idempotency behavior (despite having a 'key' parameter). It is adequate but leaves many behavioral questions unanswered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that names three key building blocks (source, bookmark, delivery profile). It is not verbose, but it is terse to the point of lacking important context. The sentence structure is straightforward but not front-loaded with enough clarifying detail. Some wasted opportunity exists because it could briefly explain the domain jargon without being much longer.
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, so the description could compensate but does not explain what the tool returns or how to use the result. With six parameters (four required), the description only briefly references three of them and does not cover 'key' or 'situation'. The sibling tools suggest a workflow (inspect, splice, verify, deliver) but the description does not position draft within that pipeline. Overall, the description feels incomplete for a tool that probably initiates a multi-step process.
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 description adds slight context by naming three parameters (source, bookmark, delivery profile) that are part of the tool's core inputs, but does not explain what these domain concepts mean or how they relate to each other. The 'party' parameter is mentioned in vague terms ('directory under casebook/parties/'), but the description adds no additional meaning beyond the schema. The 'key' parameter hint at idempotency but the description does not address it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description tells us the tool starts 'a new cut sheet for a party' given source, bookmark, and delivery profile, but it uses domain jargon ('cut sheet', 'bookmark', 'delivery profile') without explanation. Among sibling tools like inspect, splice, verify, deliver, it's not instantly clear what distinguishes 'draft' from other actions. The verb 'start' and noun 'cut sheet' provide a basic purpose, but the domain terms make it vague for a general AI agent.
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 siblings like splice, deliver, or verify. It doesn't mention prerequisites (e.g., must party exist? Must source be valid?), nor does it explain that the idempotency key is optional but recommended. The agent has no context for deciding to call draft over other tools in the set.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose behavioral traits like read-only vs. mutation, side effects, or permissions. The description only states the action without mentioning whether 'preview' is a read operation, what it produces, or any state changes. This is a serious gap.
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 efficiently communicates the core action with zero wasted words. Every part is meaningful.
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 4 parameters and no output schema, yet the description does not explain what preview produces (e.g., a video clip, thumbnail, or report), whether it modifies state, or what the output format is. Critical operational context is missing.
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 description echoes the parameter concepts (bounded span, rung) but does not add new semantic meaning beyond what the schema already provides. No additional context or constraints are introduced.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the verb 'Preview' and the resource 'bounded span of a cut sheet at a chosen rung', clearly indicating the action and target. However, given sibling tools like 'inspect', 'hear', and 'watch', it does not differentiate preview from those, so it misses the chance to clarify the unique purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'inspect' or 'hear'. There are no explicit use cases, prerequisites, or exclusion criteria, leaving the agent without decision support.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full load for behavioral transparency. It only states the action without disclosing side effects, destructive nature, idempotency behavior, permissions, or what happens to existing data. The mention of 'dress' implies modification but lacks necessary detail.
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 of 13 words that efficiently conveys the core action and scope. Every word earns its place, with no fluff or repetition.
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, yet the description omits operational details such as return values, error conditions, or the effect of the idempotency key. The agent lacks sufficient context to understand the full lifecycle of using this tool, making it incomplete for a complex operation.
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 description adds meaning beyond the schema by explaining that the template applies overlays and beat grid to the sheet. This contextualizes the 'template' and 'sheet' parameters beyond their raw definitions, despite the schema already having 100% coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool applies a named template to a cut sheet, specifying that it affects overlays and beat grid. The verb 'dress' is domain-specific but still conveys the intended action on a specific resource, distinguishing it from sibling tools like 'draft' or 'splice'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites, contraindications, or typical workflows. Without any usage context, an agent has no basis to decide between 'apply' and other sibling tools.
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 must fully disclose behavioral traits. It states the tool stops 'everything it started', hinting at cascading effects, but does not mention whether this is irreversible, whether it requires special permissions, or what happens to dependent processes. The serious consequence of destruction is implied but not explicitly flagged.
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?
Single sentence, minimal words, no redundancy. Every word is necessary and information-dense.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive, irreversible action on a running resource, the description should explicitly mention return behavior (e.g., success/error feedback), side effects, and safety considerations. With no output schema, the agent is left without important context. The tool's simplicity suggests it could be concise while still warning about consequences.
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 description does not add any parameter-specific meaning beyond what the schema provides (e.g., what a valid job handle looks like, format, or where to obtain it).
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 clear verb ('Stop') and specific resource ('a running job'), and adds scope ('and everything it started'). While it does not explicitly distinguish itself from siblings, its action is distinct enough to infer purpose.
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 on when to use this tool versus alternatives (e.g., when to cancel vs stop via inspect, or cleanup implications). The description lacks any context about prerequisites (e.g., job must be running) or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden of behavioral disclosure. It does not mention side effects, idempotency (despite the 'key' parameter), destructive potential, or auth requirements. The phrase 'Build caption imprints' hints at creation but lacks depth on 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 zero waste. Every word contributes meaning, and it efficiently conveys the core purpose without padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has four parameters, no output schema, and no annotations, the description omits crucial details such as the meaning of 'caption imprints', the behavior of the 'motion' enum, or the format of the result. The agent would lack sufficient context to use the tool confidently.
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 description adds modest context by linking 'cut sheet' to the required 'sheet' parameter and 'source's words' to the tool's input, but it does not elaborate on the 'key', 'style', or 'motion' parameters beyond what the schema already 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 ('Build') and resource ('caption imprints for a cut sheet from the source's words'), distinguishing it from sibling tools like 'preview' or 'watch' by focusing on imprint creation rather than viewing. However, the phrase 'caption imprints' is somewhat jargon-heavy and could be more universally understood.
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., 'preview', 'hear', 'draft'). It neither specifies prerequisites nor warns against misuse, leaving the agent without context for choosing 'caption' over siblings.
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 full responsibility for behavioral disclosure. It only describes the high-level operation without mentioning side effects, idempotency behavior, or what happens to the original master sheet. The schema includes a 'key' parameter for idempotency, but the description ignores this, leaving the agent uninformed about repeatable invocation.
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 of 14 words, front-loaded with the action verb and resource. It is efficient and contains no fluff. However, the extreme brevity sacrifices important context, preventing a higher score.
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 6 parameters (4 required), no output schema, and no annotations, the description is too minimal. It does not explain return values, prerequisites, or the effect of optional parameters like 'subject' and 'key'. An agent would lack sufficient information to invoke the tool correctly without inspecting the schema.
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 the baseline is 3. The description does not add any meaning beyond the parameter names and schema descriptions. It does not explain 'profile' or 'subject' in the context of carving, nor does it clarify the relationship between 'in_ticks' and 'out_ticks'. No extra value is provided.
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 ('Cut') and identifies the resource ('master cut sheet', 'clip sheet', 'delivery shape'). It clearly distinguishes from siblings like 'splice' (joining) and 'draft' (creating) by describing a unique extraction operation. However, the term 'delivery shape' is domain-specific and not explained, slightly reducing clarity.
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 explicit guidance on when to use this tool versus alternatives like 'splice' or 'draft'. It does not state prerequisites, when-not-to-use, or mention the idempotency key's role in avoiding duplicate clips. The usage context is implied but not clarified.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It implies a read-like operation ('Read'), but also mentions 'mint a source handle', which suggests creating something (a handle) and may have side effects. The description does not disclose whether this operation is reversible, requires authentication, or has rate limits. The term 'mint' is ambiguous and could mislead an agent about the tool's side effects.
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 of moderate length, conveying the core purpose concisely. It is front-loaded and contains minimal redundancy. However, it could be slightly more compact by removing 'a media file's shape and' since 'Read a file' might suffice.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that no output schema is provided, the description should clarify what a 'source handle' is and whether the tool returns it or something else. It also doesn't mention that 'include' is optional or what defaults apply. The tool has 18 siblings with various media actions (draft, splice, verify, etc.), but the description provides no context for how 'inspect' fits with those. The description is incomplete for a tool that mints a handle.
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 has high coverage (100%) with descriptions for both 'path' (workspace-relative path) and 'include' (extra maps to compute). The description does not add any additional semantics beyond the schema, so the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: reading a media file's shape and minting a source handle. The verb 'Read' and noun 'media file' are specific, though the term 'shape' is somewhat vague. It distinguishes from siblings like 'inspect' (which is the tool itself) and 'stock', 'sound', 'colour' that likely deal with different aspects.
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 like 'draft', 'verify', or 'preview'. It does not mention any prerequisites (e.g., file existence, permissions) or exclusions (e.g., unsupported media types). The agent is left to infer context from the tool name alone.
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 exist, so the description must fully disclose behavioral traits. It only says 'resolve' without explaining what that entails (e.g., does it modify state? require authorization? revertible?). The presence of an idempotency key (key param) hints at safe retries, but this is neither stated nor elaborated. The description fails to clarify whether the tool is read-only or mutating, a critical gap.
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 of 17 words. Every phrase ('resolve the sound plan', 'music lane', 'level', 'loudness target') directly contributes to understanding. No fluff or redundancy. Excellent conciseness for a tool with 5 parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite good parametric documentation in the schema, the description omits crucial details: what the tool returns (no output schema), the nature of 'resolve' (analysis vs. mutation), edge cases (e.g., out-of-bounds music level is refused, not clamped), and required permissions. For a tool with no annotations and moderate complexity, this brief description leaves an agent underinformed.
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 baseline is 3. The description adds 'the music lane, its level, and the loudness target', which maps to music, music_level_millibel, and target_loudness, reinforcing their roles. However, it does not explain parameters beyond what the schema already states (e.g., 'key' for idempotency, 'sheet' as the cut sheet handle). No new semantic value is provided.
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 tool's purpose: resolving a sound plan for a cut sheet, specifying the music lane, its level, and loudness target. This distinguishes it from siblings like 'hear' or 'preview' which likely involve playback or review, not planning. However, the verb 'resolve' is somewhat vague—could mean compute, finalize, or apply—reducing precision.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'draft', 'apply', or 'hear'. The description implies use when setting up a sound plan, but does not state exclusions, prerequisites, or typical workflows. Without this, an agent may misuse the tool in contexts better served by a sibling.
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 of behavioral disclosure. It only mentions adding or amending segments but omits critical behaviors such as idempotency (key parameter), error conditions (e.g., missing sheet or source), or the effect of the 'segment' parameter. The hint about 'why' never reaching pixels is a minor detail but insufficient overall.
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, front-loaded with the key actions. It is concise and avoids excess words, though it could be slightly more structured to separate the two modes (add vs. amend) for clarity.
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 (9 parameters, 6 required, no output schema, no annotations), the description is too brief. It does not explain what a 'cut sheet' is, what happens on success, error handling, or how the output is returned. The agent has insufficient context to use the tool correctly without additional knowledge.
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 each parameter. The description adds minimal semantic value beyond the schema—it loosely maps 'amend' to the 'segment' parameter but does not elaborate on tick semantics or the relationship between parameters. The baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add a segment' or 'amend an existing segment's edges') and the resource ('cut sheet'). It is specific and distinguishes the tool's purpose from generic operations, though it could benefit from clarifying what a 'cut sheet' is in the context of the 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 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 splice versus other tools like 'carve', 'stock', or 'sound'. There is no mention of prerequisites, alternatives, or contexts where this tool is appropriate or inappropriate.
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 full burden. It mentions 'test-encoding' and cached results (via force param), but does not disclose side effects, performance characteristics, or what the tool actually runs internally. Minimal behavioral insight.
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?
Single sentence, no fluff. Front-loaded with action verb. Could be slightly more structured, but efficiency is good.
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?
No output schema and low parameter count (2, none required). Description does not explain return values or what 'surveys' are. For a discovery tool, it is moderately complete but leaves gaps for an AI agent to interpret correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (both parameters have descriptions in the input schema). The description adds the context of 'test-encoding' but does not provide additional semantics beyond what the schema already states. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose is to discover machine capabilities via test-encoding rather than feature lists. It uses a specific verb ('find out') and resource ('capabilities'), but does not differentiate from sibling tools like 'inspect' or 'hear'.
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 on when to use this tool versus alternatives. The description implies it is for exploration, but does not specify when not to use it or provide alternative tool names for missing filtering functionality.
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 full behavioral disclosure burden. It states the tool 'run[s] every gate' and reports pass/block status, but doesn't mention side effects (e.g., does it modify the sheet?), permissions needed, failure modes, or performance implications (e.g., is it expensive for many gates?).
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, clear sentence that efficiently communicates core purpose. Could arguably be more specific (e.g., defining 'gate'), but is not verbose or wasteful.
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 1 parameter with full schema coverage and no output schema, the description is adequate for basic use. However, given absence of annotations and output schema, the description could better explain what 'passes' vs 'blocks' means in the return format to compensate.
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 has 100% description coverage defining 'sheet' as 'A cut sheet handle', so the baseline is 3. The description doesn't add further parameter semantics (e.g., what a valid handle looks like), but the schema is sufficient for this single 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 uses specific verbs ('run every gate') and identifies the domain ('cut sheet'), clearly differentiating it from sibling tools like 'inspect' or 'draft'. However, it doesn't explain what a 'gate' is, which slightly reduces clarity for agents unfamiliar with the domain jargon.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance is provided on when to use this tool versus siblings like 'inspect' (which might also analyze a sheet) or 'draft'. It implies verification use via 'report what passes and what blocks' but lacks exclusions or comparative 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 bears full responsibility for behavioral disclosure. It only states the core operation, omitting key traits such as whether the tool is asynchronous, idempotent (beyond the key parameter), destructive, or requires specific sheet states. The one-word 'finished' implies a prerequisite but does not elaborate on failure modes or side effects.
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, well-constructed sentence that front-loads the main action without filler. It earns a 4 for efficiency, though a second sentence elaborating on usage or behavior would have made it a 5.
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 3 parameters (one required), no output schema, and no annotations, the description is insufficiently complete. It fails to explain what the tool returns, whether it is synchronous, or what state the sheet must be in before calling. For a tool performing encoding and muxing—operations that could be slow or error-prone—this information is critical for 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 coverage is 100%—all three parameters (key, sheet, motion) already have clear descriptions in the schema. The tool description adds no additional meaning about parameter usage, constraints, or interactions. A baseline of 3 is appropriate since the description does not degrade understanding but also does not enhance it.
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 specific verbs ('encode and mux') and identifies the resource ('finished deliverable for a cut sheet'). This verb+resource combination is distinct from sibling tool names like 'inspect', 'draft', or 'preview', enabling an agent to differentiate it easily.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool vs alternatives. Siblings like 'preview' or 'verify' might be used before or after delivery, but the description does not mention prerequisites, sequencing, or conditions that would help an agent decide between them.
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 disclose side effects and safety profile, but it only states that it decides colour treatment without indicating whether it modifies the cut sheet, requires permissions, or what the output is. The phrase 'including whether a transfer stage is inserted' hints at a possible mutation but is ambiguous.
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 immediately states the verb and object, with no wasted words. However, it is under-specified, which is a completeness issue rather than a conciseness issue.
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 four parameters with an enum and no output schema, requiring the description to explain return values and effects. The description does not cover what happens after the decision, what a 'transfer stage' is, or what the caller should expect, making the tool under-explained.
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?
All four parameters have schema descriptions (100% coverage), so the description itself adds no additional meaning to the parameters. The term 'cut sheet' aligns with the `sheet` parameter, but no deeper semantics are provided beyond 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 uses the specific verb 'Decide' with the resource 'cut sheet' and mentions a key aspect (transfer stage insertion), making its function clear and distinct from sibling tools like apply or preview.
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 usage guidance is provided; the description does not mention when to use this tool over alternatives or any prerequisites/exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must fully disclose behavior. It states the tool tracks shot changes and framing path, implying analysis rather than output creation. However, it does not mention whether this tool modifies state, requires specific permissions, or what system constraints apply.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence with no waste, front-loading the core action and output. It is appropriately succinct.
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 deals with framing paths and output shape, the absence of an output schema is notable. The description does not explain what 'framing path' means or what the tool returns, and the sibling tools list is large with no differentiation hints. The description lacks sufficient context for effective tool selection.
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 all three parameters. The description mentions 'track shot changes and the subject' which implies the 'subject' and 'source' parameters but adds no extra detail beyond the schema. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verbs ('track shot changes and the subject') and a clear resource ('source'), producing a 'framing path'. While it distinguishes the tool's purpose, it could better differentiate from siblings like 'inspect' or 'hear' that might also analyze a source.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'inspect', 'hear', or 'preview'. The description does not mention non-use cases, context, or prerequisites.
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 of behavioral disclosure. The description implies a write/mutation operation ('Place an element') but does not state whether it is destructive, reversible, or requires specific permissions. It adds value by specifying placement constraints (at a tick, for a hold) but fails to disclose other essential behaviors like idempotency (though 'key' parameter hints at it) or effects on existing sheet elements.
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, focused sentence that states the core action without unnecessary detail. It could be improved by placing domain-specific terminology in a more front-loaded manner, but overall it is appropriately concise.
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 complex domain (cut sheets, elements, ticks, holds) and lack of output schema, the description is partially complete. It explains the what, where, and when but omits return values or side effects. With no annotations and no output schema, more detail is warranted for a tool with 6 parameters and nested objects, especially to clarify the 'fields' object and idempotency behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers all parameters with descriptions (100% coverage), and the description complements this by explaining the domain-specific action for the main parameters ('at a tick' and 'for a hold'). However, the description does not clarify the 'fields' parameter syntax or the role of 'key', leaving some semantic gaps.
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 specifies the action ('Place an element'), the target ('onto a cut sheet'), and the conditions ('at a tick for a hold'). It distinguishes from siblings like 'splice' or 'draft' which suggest different operations. However, it does not differentiate from potential similar tools like 'apply', and lacks a verb-resource structure that fully clarifies domain-specific terms like 'element', 'cut sheet', 'tick', and 'hold'.
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 its siblings. With 17 siblings including tools like 'inspect', 'draft', and 'preview', an agent has no context for choosing 'place' over alternatives. There is no mention of prerequisites (e.g., must a sheet be created first?), exclusions, or typical use cases.
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 should reveal behavior. It states what the tool does but does not disclose matching rules (case sensitivity, partial matches), error handling (e.g., text not found), or side effects. Returns tick range but format unspecified.
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, clear sentence with no wasted words. However, it could be slightly more structured (e.g., listing output) without becoming verbose.
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 5 parameters, no annotations, and no output schema, the description is too minimal. It fails to explain the return format, ordering of results, or behavior when no match is found – critical for correct agent 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 each parameter already has a clear description. The tool description adds no additional meaning beyond what the schema provides – baseline 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 uses a specific verb ('Locate') and resource ('something said in a source') and clearly states the output ('get the tick range'). This distinguishes it from sibling tools like 'hear' (listen) or 'caption' (transcribe).
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 on when to use this tool vs. alternatives (e.g., 'hear' for listening, 'inspect' for metadata). No exclusions or prerequisites mentioned.
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 disclose behavioral traits. It mentions 'reading the result as text before anything encodes' but does not explain what 'encodes' means, whether the operation is read-only, requires permissions, or has rate limits. Important behaviors like output format or side effects are 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 sentence that is front-loaded with the action and avoids redundancy. Every word serves a purpose with no wasted space.
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?
While the description explains the core transcription function, it omits details about the return format (how timings are represented), the role of 'tier' and 'consent', and does not compensate for the lack of an output schema. Given four parameters and no output schema, the description is not fully complete.
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 100% with minimal per-parameter descriptions (e.g., 'A source handle', 'draft, local, or cloud.'). The tool description adds meaning by stating the tool transcribes to words with timings and reads as text, enriching the context beyond the schema alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool transcribes a source to words with timings, using a specific verb ('transcribe') and resource (source). It also adds nuance about reading the result as text before encoding, which distinguishes it from siblings like 'caption'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as 'caption', 'draft', or 'sound'. The description only states what it does without offering context on when it is appropriate or not.
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

splicedeck MCP server — quality and maintenance score on Glama

Copy to your README.md:

[![splicedeck MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/ihuzaifashoukat/splicedeck/badges/card.svg)](https://glama.ai/mcp/servers/ihuzaifashoukat/splicedeck)

Score Badge

Copy to your README.md:

[![splicedeck MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/ihuzaifashoukat/splicedeck/badges/score.svg)](https://glama.ai/mcp/servers/ihuzaifashoukat/splicedeck)

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/ihuzaifashoukat/splicedeck'

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