adobe-premiere-cc-mcp

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation5/5
Each tool has a clearly distinct purpose, with detailed descriptions that prevent confusion. Even similar tools like get_clip vs get_timeline operate at different scopes (single clip vs whole sequence), and grade_clips vs set_lumetri target group vs individual clips. No two tools appear to do the same thing.
Naming Consistency4/5
The vast majority of tools follow a consistent verb_noun pattern (get_, set_, list_, create_, delete_, add_, etc.). Minor exceptions like 'ping' and 'contact_sheet' deviate from this pattern, but they are easily recognizable and do not significantly harm overall consistency.
Tool Count2/5
With 41 tools, the server is heavily overloaded. While Premiere is a complex application, this many tools in one MCP server makes it unwieldy and could benefit from being split into focused sub-servers (e.g., editing, effects, export). The number falls well beyond the 'too many' threshold of 25.
Completeness4/5
The tool set covers the core editing workflow well: project management, sequence handling, timeline operations, clip properties, effects, grading, markers, playhead, export, and saving. Minor gaps exist, such as no generic effect property setter (only specific ones like set_lumetri and set_scale) and limited transition editing, but run_script provides an escape hatch for these cases.
Average 4.2/5 across 41 of 41 tools scored. Lowest: 3.2/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 65 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 MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It tells the units and scope, but does not explicitly state that this is a read-only operation with no side effects, nor does it address edge cases like missing active sequence or timecode format. The description adds some value but leaves significant transparency gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no superfluous words. It efficiently conveys the resource, scope, and units.
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 simple with no parameters and no output schema, but the description provides essential context (position, scope, units). It doesn't mention potential error conditions (e.g., no active sequence) or timecode format specifics, so completeness is adequate but not thorough.
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?
There are zero parameters, so the baseline is 4. The description adds semantic context by specifying 'in the active sequence' and 'in seconds and as timecode', which clarifies what the returned value represents, even though no parameters exist.
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 as retrieving the current playhead position, specifying the scope ('active sequence') and units ('seconds and timecode'). It lacks an explicit verb like 'get' or 'return', but the noun-phrase form is unambiguous and distinguishes it from sibling tools like set_playhead.
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 doesn't mention when to use this tool versus alternatives, nor does it state any prerequisites (e.g., requiring an active sequence). The intended use is implied by the name and description, but explicit context is absent.
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 mentions 'confirm it exists,' which indicates a post-creation verification, but it does not disclose what happens on failure, whether duplicate names are allowed, or any permissions required. For a mutation tool, this is insufficient behavioral 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 concise sentence with no redundant wording. It clearly and efficiently communicates the tool's action and the confirmation step.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description covers the core action and verification. However, it does not explain the return value or behavior when the bin already exists, which leaves some context gaps. It is adequate but not fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully describes the only parameter 'name' (with description 'Bin name'), achieving 100% schema description coverage. The tool description adds no additional parameter 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.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Create a bin in the project panel and confirm it exists.' It uses a specific verb ('create'), identifies the resource ('bin in the project panel'), and adds a verification step. This distinguishes it from sibling tools like 'create_sequence_from_items'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the usage (when you need to create a bin) but does not provide explicit guidance on when to use it vs alternatives or any exclusions. There are no directly competing sibling tools, so reliance on the name and description is acceptable, but still lacks formal guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses a constraint ('Paths must be absolute') and an unusual post-condition ('confirm the item count grew'), but does not mention side effects like creating a bin, potential for overwriting items, or any permission requirements. More context about the mutation behavior would be valuable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no wasted words. The first sentence delivers the core purpose, and the second adds a critical constraint. It is front-loaded and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a relatively simple 2-parameter tool with no output schema, the description covers the core purpose, a key constraint, and a behavioral confirmation. It lacks explicit information about return values or error handling, but given the simplicity and full schema coverage, it is sufficiently complete for an agent to use the tool effectively.
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 reinforces that paths are absolute but adds no new meaning beyond the schema's descriptions for file_paths and bin_name. It does not explain the bin_name parameter's role or how it relates to the project panel.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Import'), the resource ('media files'), and the destination ('project panel'), along with a distinctive outcome ('confirm the item count grew'). It effectively distinguishes this tool from siblings like create_bin or list_project_items by focusing on the import action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for importing media files, but does not explicitly mention when to use this tool over alternatives or any exclusions. It lacks references to related tools like create_bin or list_project_items, leaving the agent to infer context from the tool name and schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of disclosing behavior. It mentions the effect ('Change a clip's playback speed') and a confirmation behavior ('Confirms the new duration'). However, it does not mention reversibility, permissions, or any side effects, which are relevant for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three concise sentences with no wasted words. The first sentence states the core purpose, the second clarifies the parameter semantics, and the third discloses an outcome. Perfectly front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool with no output schema, the description covers the essential aspects: what it does, how the parameter behaves, and what the user can expect (confirmation of new duration). Minor gaps include not specifying the nature of the confirmation or error conditions, but these are not critical for such a straightforward 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?
Schema coverage is 100% (both parameters described). The description adds value by elaborating on 'speed_percent' with concrete examples (100, 50, 200) and their relationship to duration, going beyond the schema's minimal '100 = normal speed'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('Change') and resource ('a clip's playback speed'). It immediately distinguishes itself from sibling tools by focusing on speed adjustment. The name further reinforces the 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?
The description provides no guidance on when to use this tool versus alternatives, nor does it state any prerequisites or exclusions. It only explains the speed semantics, leaving the usage context implicit.
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 burden. It discloses an important behavioral effect (muting a video track hides it from monitor/exports) and implies a return value ('read the state back'), but it does not detail the exact response format or other side effects like reversibility beyond unmuting.
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 concise sentences, front-loaded with the primary action and followed by a key behavioral note. Every sentence earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple setter tool with no output schema, the description is mostly complete: it explains purpose, key behavior, and parameter context. The only minor gap is the exact return type/value of 'read the state back', but it is still understandable.
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 documents 2 of 3 parameters, and the description adds context by mentioning 'video or audio', which corresponds to track_type. However, it does not add meaningful detail beyond the schema; track_index and muted are already clearly described. The missing track_type description is compensated by its enum values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Mute or unmute') on a specific resource ('video or audio track') and adds that it reads the state back. It distinguishes itself from sibling tools by focusing on track-level state, not clip-level operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (use when you want to mute/unmute a track), but it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. It is clear enough from purpose, but lacks direct guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states that the tool lists bins and media and includes node IDs, which is important expected behavior. However, it does not mention edge cases like whether a project must be open or if the list is paginated, leaving some gaps. The basic read-only nature is implied by 'List' but not explicitly stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core purpose and followed by a practical use case. Every word contributes meaning, and there is no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no output schema and no annotations, the description provides key details: what is listed (bins and media) and what is returned (node IDs). It also gives a use-case context. However, it omits the 'limit' parameter semantics and return format details, so it is not fully complete.
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?
The schema has 0% description coverage, so the description must explain the 'limit' parameter. It does not mention 'limit' at all, leaving the agent to guess its meaning from the default and maximum values in the schema. This is a significant gap for a single-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'List the project panel contents: bins and media, with the node ID of each.' This identifies a specific verb ('List'), a resource ('project panel contents'), and the key output ('node ID'). It also distinguishes itself from sibling tools like get_clip (which targets a single clip) and create_bin (which creates a bin).
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 provides a clear usage context: 'Use this to find footage before adding it to a timeline.' This tells the agent when to use the tool and implies its role in a workflow. However, it does not explicitly mention alternatives or when not to use it, falling short of a perfect 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses a behavioral detail ('then confirm it exists'), which adds some transparency about the tool's verification step. However, it does not explain side effects, failure handling, or whether it modifies the active sequence in a way beyond the obvious add. This is a moderate level of disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences long, front-loaded with the main action, and every sentence adds value. The first states the core function, the second provides practical use cases. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (4 params, no output schema, no annotations), the description covers the essential aspects: what it does, when to use it, and a hint of behavioral verification. It does not explicitly describe the return value, but 'confirm it exists' implies a confirmation result. This is reasonably complete for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all four parameters documented in the schema. The description does not add additional semantic meaning beyond the schema, so the baseline of 3 is appropriate. It neither compensates nor detracts from the schema's clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add a marker to the active sequence at a given time') with a specific verb and resource. It also mentions the confirmation behavior, distinguishing it from sibling tools like list_markers and delete_marker. The use cases ('noting beats, cut points or review comments') reinforce its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives a clear usage context: 'Handy for noting beats, cut points or review comments.' This implies when to use the tool but does not explicitly mention alternatives or when not to use it. It provides enough context for selection without exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool confirms the transition appeared on the track (verification behavior) and notes the handle requirement and possible refusal/shortening, which are important behavioral traits beyond a simple mutation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first states the purpose and verification, the second adds an important caveat. It is front-loaded, concise, and every sentence contributes meaningful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with three parameters and no output schema, the description covers the essential purpose, a critical prerequisite (handles), and the confirmation behavior. It does not detail return values, but that is a minor gap given the tool's simplicity and the presence of complete schema descriptions.
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 provides complete descriptions for all three parameters (at, node_id, transition_name), so schema coverage is 100%. The description adds no parameter-specific semantics beyond what the schema already documents, making the baseline 3 appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Add a video transition at a clip's head or tail' and includes a verification step. It is specific about the resource (clip) and position (head/tail), distinguishing it from siblings like list_transitions (which lists available transitions) and apply_effect (which applies effects).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for adding transitions and provides a key prerequisite: 'a transition needs media beyond the cut to draw from; without handles Premiere may refuse or shorten it.' However, it does not explicitly state when to use this vs. alternatives or provide 'when not to' guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It adds that the tool will 'confirm it attached,' which is a useful behavioral trait. However, it doesn't disclose error behavior, reversibility, or requirements beyond that, leaving significant gaps for a mutation tool without annotation support.
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 concise sentences with no wasted words. The action is front-loaded, and the pointer to list_effects is clearly separated and purposeful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with two well-documented parameters. The description covers the core action, mentions confirmation behavior, and gives a prerequisite. It does not elaborate on return values or error conditions, but given the simplicity and no output schema, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full descriptions for both parameters, including an example for effect_name. The description's mention of 'by name' adds little beyond the schema. With 100% schema coverage, the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Add') with a clear resource ('video or audio effect to a clip') and mechanism ('by name'), clearly distinguishing it from siblings like list_effects or add_transition. The 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 description explicitly directs users to list_effects for exact names, providing an alternative and prerequisite. It implies when to use this tool (applying a known effect) but does not explicitly contrast with related tools like add_transition, so it falls slightly short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses that the tool writes a full-resolution still and frames it as a visual verification step, which adds useful context. However, it does not mention whether existing files are overwritten, file permission needs, or what the tool returns upon success/failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero fluff. The first sentence defines the action and scope, the second provides the key usage scenario and rationale. Information is front-loaded and every phrase earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter tool with fully described schema and no output schema, the description covers the core purpose and motivation for use. It does not discuss error handling or return values, but the 'use to look at your work' directive implicitly fills that gap by pointing to the file itself as the artifact. This is sufficient for the tool's low complexity.
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% for both parameters (output_path and time_seconds). The description adds no parameter-specific details beyond the schema, merely restating 'at a given time' which aligns with time_seconds. Baseline 3 is appropriate since the schema fully documents the 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 ('Write') and resource ('full resolution still of the sequence at a given time'), clearly distinguishing it from siblings like export_sequence (full export) and contact_sheet (grid of frames). It leaves no ambiguity about what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit usage context: 'after a grade or a reframe' and contrasts with 'trusting a tool's success flag'. It provides a concrete scenario and an implied alternative, though it does not explicitly mention sibling tools or a 'when not to use' condition.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses key behavioral requirements: ES3 syntax constraints, mandatory ending with __result/__error, and a list of available helpers. However, it does not mention timeout behavior, error handling, or the potential for destructive side effects from raw ExtendScript execution.
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 information-dense with no filler. Every sentence delivers functional detail: escape-hatch purpose, ES3 constraints, return contract, and helper list. It is front-loaded with the key purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a raw scripting tool without an output schema, the description is quite complete. It explains how to write code, what syntax to use, how to return results, and lists all available helper functions. Missing details are timeout semantics and the exact structure of the __result object, but the description provides enough to use the tool effectively.
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 describes 'code' and gives timeout_ms a default but no description. The tool description adds meaning for 'code' by explaining ES3 syntax, the required return pattern, and helpers. It does not clarify the timeout_ms parameter behavior or interaction with the timeout parameter.
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?
Clearly states it 'run[s] raw ExtendScript in Premiere' and positions itself as an 'escape hatch' for anything not covered by typed tools. This distinguishes it from the many sibling tools that perform specific operations.
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?
Explicitly says use it 'for anything the typed tools do not cover,' implying it is a last resort. It does not explicitly name alternatives or state when not to use it, but the escape-hatch framing provides clear context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It adds useful details: the operation applies to 'every clip on a track' and returns 'the new clip count' for confirmation. It does not mention side effects like undo or edge cases, but the provided context goes beyond the bare name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no filler. It front-loads the action and adds a brief note on the return value, making it maximally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description explains what the tool does, its scope, and the return value, which is adequate given no output schema and a moderate number of parameters. It lacks edge-case handling but is otherwise complete for the tool's purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers 67% of parameters with descriptions (track_index and time_seconds), and track_type has an enum/default that clarifies its meaning. The tool description does not add further parameter-specific information, so it does not exceed the schema's coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action 'Cut every clip on a track at the given time' which is a specific verb+resource. It also distinguishes from sibling tools like trim_clip or remove_clip by clarifying it is a split operation equivalent to the razor tool.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides an analogy to the razor tool but does not explicitly state when to use this tool versus alternatives like trim_clip or remove_clip. There is no mention of exclusions or preferred scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior. It clearly states that trimming the end shortens the tail and trimming the start moves the head later, leaving a gap, which reveals the non-ripple side effect. It also mentions confirming the new duration, adding context. However, it doesn't mention reversibility, permissions, or what the confirmation entails, so it's slightly below a perfect score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action in the first sentence and supporting detail in the second. Every word is informative with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description, combined with a full-schema-coverage input schema, provides sufficient context for a trim operation. It explains the two edge behaviors and the consequential gap, which is important for the agent to understand the operation's side effect. However, it doesn't mention prerequisites (e.g., active sequence) or return values, leaving some minor 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 description coverage is 100%, so the baseline is 3. The description adds no additional parameter-level detail beyond what the schema already provides for edge, node_id, and time_seconds. The behavioral explanation of edge effects is a minor addition, but not enough to raise the score.
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 ('Trim') and resource ('a clip's start or end on the timeline'), clearly distinguishing this from sibling tools like move_clip, split_clip, or remove_clip. It also explains the two edge cases, further clarifying its scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by explaining the effect of trimming start vs end, but it does not explicitly state when to use this tool over alternatives or mention any exclusions. It doesn't contrast with move_clip or split_clip, leaving some ambiguity about selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It adds useful behavioral details: settings derived from the first item, no preset required, no dialog, and confirmation of existence. However, it does not mention potential side effects, permissions, or failure behavior, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each earning its place: the action, the behavioral details, and the typical use case. No redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with no output schema, the description covers purpose, usage, and key behavior. However, it does not state what is returned (if anything) or prerequisites like whether items must already exist in the project, leaving some uncertainty for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by noting 'one or more' items and that 'derives settings from the first item', clarifying the significance of item order—something the schema does not convey.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Create a new sequence built from one or more project items, and confirm it exists.' It uses a specific verb 'create' and a specific resource 'new sequence from project items', distinguishing it from sibling tools like list_sequences or add_to_timeline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear usage context: 'Useful for making a scratch sequence to experiment in' and notes 'needs no preset and opens no dialog.' It does not explicitly name alternatives or when-not-to-use, but the context is sufficient to understand when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description discloses batch behavior ('in one pass'), that values are read back, and that reports are per-clip so one failure does not hide the rest. This gives the agent insight into partial failure semantics. However, it doesn't state whether existing Lumetri effects are overwritten or whether the operation is reversible.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each with a distinct function: mechanism, usage guidance, and failure reporting. No redundancy or filler.
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 12-parameter mutation tool with no annotations and no output schema, the description leaves significant gaps: it doesn't explain parameter ranges, return value structure, or behavior with clips that already have a grade. It provides a good high-level model but isn't sufficient for full autonomous invocation.
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 only 33%, and the description adds no parameter-level semantics. It references 'Lumetri Basic Correction' as a concept, but 8 numeric parameters are left undefined with no ranges or units, leaving the agent unable to reason about appropriate values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it applies a batch Lumetri Basic Correction to a group of clips in one pass, which distinguishes it from single-clip tools like set_lumetri and get_grade. The verb+object structure is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly recommends grading clips that share lighting conditions together and warns against a single correction across mixed lighting. This provides a clear when-to-use/not-use rule, even if alternatives aren't named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It explicitly discloses the read-only, non-mutating behavior ('Read only, so it is always safe to run') and lists the specific checks performed. The only gap is that it doesn't describe the output format or how the report is presented.
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 compact two-sentence structure, front-loaded with the main purpose. The list of checks is comprehensive yet concise, and the safety note is a single useful clause. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations or output schema, the description covers the essential behavior, the safety profile, and the full checklist of issues. The only notable gap is the absence of any detail about the report's structure, which an agent might need to interpret results correctly. Overall, it is sufficient for a straightforward inspection tool.
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 provides clear descriptions for both parameters (max_scale and max_audio_db) with defaults. The description reinforces these defaults (100 percent, unity) but adds no additional semantic meaning beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a clear action ('Inspect the whole sequence') and a specific object ('the edit'), then enumerates exact problem types (scaled clips, unanalysed stabilisers, audio spikes, etc.). This distinguishes it from sibling editing tools that modify the timeline, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly frames the tool as a quality-check step for edits, and explicitly states it is 'always safe to run' due to being read-only. It doesn't explicitly exclude alternatives or state when not to use it, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the disclosure burden. It explicitly warns about a key behavior: 'Slow, since every frame is a real render.' It also explains that stills are taken from the middle of each clip and that file paths are returned, providing useful context beyond a simple 'export' statement.
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 three sentences, each earning its place: the first states the core action, the second explains the intended use, and the third warns about performance. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is moderate complexity with 3 documented parameters. The description covers the operation, expected output (file paths), use case, and performance caveat. It does not specify which sequence or project is used, but sibling tools like set_active_sequence imply the active sequence context, making this sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already defines all parameters (output_dir, limit, track_index). The description adds context about what the output represents (one still per clip from the middle) but does not elaborate further on individual parameter meanings or constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Export one still per clip on a video track, taken from the middle of each clip, and return the file paths.' This is a specific verb+resource combination that distinguishes it from siblings like export_frame (single frame) and export_sequence (whole sequence).
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?
It provides a clear use case: 'Read the images afterwards to judge a grade across the whole edit at once instead of one frame at a time.' This implies when to use it (evaluating overall grade) and contrasts with checking individual frames, though it does not explicitly name alternatives or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the irreversible nature of deletion, the tolerance-based matching, and that it reports the remaining count. This adds meaningful context beyond the raw action, though it does not cover error cases or permissions.
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 well-structured sentences: the first delivers the core action and outcome, the second provides a critical caution. No filler or redundancy, and the warning is front-loaded for safety.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple deletion tool with no output schema, the description covers the essential behavior, the tolerance matching, the count report, and the irreversible warning. It lacks edge-case handling (e.g., no marker found), but given the low complexity, this is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both time_seconds and tolerance_seconds documented. The description's mention of 'small tolerance' aligns with the tolerance_seconds parameter but does not add meaning beyond what the schema already provides, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (Delete), the resource (marker), and the specific behavior (nearest a given time, within a small tolerance). It distinguishes itself from sibling tools like add_marker and list_markers by its focus on deletion and the matching logic.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides a clear warning to check list_markers before deleting, indicating a prerequisite and cautioning against irreversible action. However, it does not explicitly mention alternative tools or scenarios where this tool should not be used, so it falls slightly short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and delivers by detailing exactly what is returned (timing, effects, keyframe state). It implies a safe read operation but doesn't mention potential costs or permissions, which is acceptable for a getter.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste. The main functionality is front-loaded, and the second sentence adds a practical usage note without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, the description enumerates the returned data sufficiently to set expectations (timing, in-point, effects, keyframe state). It could mention the output format but the scope and content are clear, making it complete for a simple one-parameter getter.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter node_id is 100% covered by the schema description, so the baseline of 3 applies. The tool description doesn't add additional meaning beyond tying it to 'one clip', but the schema already provides sufficient clarity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('get') and resource ('clip') and enumerates the content (timing, in-point, effects, keyframe state), clearly distinguishing it from siblings like get_timeline or get_grade. It leaves no doubt about what the tool retrieves.
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 second sentence explicitly frames the tool as a pre-modification read: 'Read this before changing a clip so you know what you are overwriting.' This provides clear context for when to use it, though it doesn't explicitly name 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?
With no annotations, the description must indicate this is a safe read-only operation. The verb 'List' implies no modification, and 'every' conveys completeness of the returned set. It does not explicitly mention side effects, but for a simple enumeration no side effects are expected.
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 delivers the essential scope and purpose without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one optional parameter and no output schema, the description is adequately complete. It specifies the result as 'every video transition name', which implies an array of strings, and references add_transition for usage context. It could have been more explicit about the return format, but this is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% since the filter parameter is fully described as a 'Case-insensitive substring'. The description adds no extra parameter detail, but the high schema coverage makes 3 the appropriate baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('List') and the resource ('every video transition name Premiere can apply'). It also explicitly connects to a sibling tool ('for use with add_transition'), which distinguishes it from similar enumeration tools like list_effects.
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?
It states the intended downstream use ('for use with add_transition') and implies it is a lookup tool for transitions. However, it does not explicitly contrast with alternatives or state when not to use it, so slightly below the top score.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It discloses the move is same-track, confirms success ('confirm it landed'), and specifies a failure condition (destination already occupied). This goes beyond a minimal description, though it does not discuss side effects like undo behavior or return format.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences contain exactly the essential information: the action, constraint (same track), confirmation, and failure condition. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, no output schema, and no annotations, the description adequately covers purpose, constraints, and conflict behavior. It could be more explicit about what 'confirm it landed' returns or prerequisites, but it is sufficiently complete for an agent to invoke this tool safely.
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 covers both parameters fully (node_id with description, time_seconds with description and minimum). The description adds little beyond the schema, only reinforcing that time_seconds is a new start time. With 100% schema coverage, 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 clearly states the tool moves a clip to a new start time on its own track, which is a specific verb+resource combination. It also distinguishes itself from sibling tools like trim_clip and split_clip by its unique action and the fact that it stays on the same track.
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?
It provides clear context: the clip remains on its own track and the operation fails if the destination is occupied. While it does not name explicit alternatives, it implies when to use this tool (repositioning within a track) and gives an important exclusion (cannot move to an occupied destination).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the key behavioral trait that setting the active sequence affects all other tools, which is important for an agent to know. It does not mention error handling or return values, but for a simple setter, this is sufficient. It goes beyond the schema by explaining the global effect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the core action, and the second sentence adds the matching method and the effect on other tools. There is no wasted wording; every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema, no annotations), the description covers the essential context: what it does, how to identify the sequence, and the impact on other tools. It omits details like return behavior or error cases, but those are not critical for a simple state-setter. It is complete enough for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already describes the parameter as 'Sequence name or ID' (100% coverage). The description's phrase "Match by name or sequence ID" adds no new meaning beyond the schema. Since the schema fully documents the parameter, a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: "Make a sequence the active one" with a specific verb and resource. It also explains the consequence ("so every other tool operates on it"), which distinguishes it from any sibling tool. No other sibling has a similar purpose, so it 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 description provides clear context for when to use the tool: it is the tool that sets the target for all subsequent operations. It implies usage (before operating on a specific sequence) but does not explicitly name alternatives or exclusions. Since no sibling tool serves this role, the lack of explicit alternatives is acceptable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations available, the description carries the full burden, and it does a good job: it discloses the partial-update behavior ('Only the fields you pass change') and the limitation that the creative Look cannot be set by script, only its intensity. It does not explain error handling for clips missing the effect, but it does state the prerequisite, which is the most critical behavioral constraint.
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 three sentences, each earning its place: the first states the core action, the second explains partial-update behavior, and the third covers the prerequisite and scripting limitation. It is front-loaded and free of redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (11 params, no output schema, no annotations), the description covers essential contextual points: prerequisites, partial updates, and the Look intensity limitation. It does not describe the return value beyond 'read them back' or enumerate all parameters, but the most important information for correct use is present.
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 low (27%), and the description adds limited parameter-specific meaning. It clarifies that the numeric fields correspond to Lumetri Basic Correction values and that look_intensity only controls intensity of an already-selected Look, which is useful. However, it does not explain units, ranges, or default values for most parameters, relying on the self-explanatory property names.
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 identifies a specific verb ('Set') and resource ('Lumetri Basic Correction values on a clip'), clearly distinguishing this from sibling tools like grade_clips or apply_effect. It also states the partial-update behavior ('Only the fields you pass change') and mentions the read-back capability, making the tool's scope 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 description gives a clear prerequisite: the clip must already have a Lumetri Color effect, and explicitly directs users to apply_effect to add one. It does not explicitly mention when not to use this tool versus alternatives like grade_clips, but it provides enough context for an agent to decide when this tool is applicable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It transparently states both the mutating action ('Move the playhead') and the additional behavior of reading the position back. While it does not cover prerequisites like an active sequence, the core behavior is clearly disclosed for a simple state changer.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary action and a practical use case. Every word earns its place, with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no output schema and no annotations, the description is compact yet sufficient. It explains purpose, the parameter unit, and a concrete usage scenario. It could mention required context (e.g., an active sequence), but the description is largely complete for its complexity.
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 has 100% parameter description coverage for 'time_seconds' ('Sequence time in seconds'). The description's mention of 'time in seconds' reinforces but does not add significant new information beyond the schema. The baseline of 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool moves the playhead to a specified time and reads the position back. This is a specific verb+resource combination and distinguishes the tool from siblings like get_playhead (which presumably only reads) and export_frame (which captures at the playhead position).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly mentions a key use case ('Useful before export_frame, since that captures wherever the playhead lands'), giving clear context for when to use the tool. It does not explicitly compare with alternatives like get_playhead, but the provided use case differentiates it from read-only tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses both the mutation ('Set') and a verification read ('read it back to confirm'), as well as an irreversible consequence (detail loss on export). It doesn't detail permission requirements, failure behaviors, or exact return format, but exceeds the bare minimum.
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 succinct, with no filler. It front-loads the primary action and then provides a vital caution in the same compact length, all in two sentences. Every clause contributes actionable information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple setter with two fully documented params, the description covers the main behavior, the scale semantics, and a critical edge-case warning. It does not explicitly define the return value of 'read it back', but the confirmation behavior is implied. Overall, the description is reasonably complete for an agent to use this tool effectively.
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 adds minimal param context by rephrasing '100 means native pixels' which loosely maps to the schema's '100 = original size'. No additional syntax or format details 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 a specific verb 'Set' and resource 'a clip's Motion scale', clearly distinguishing it from sibling tools like set_clip_speed or trim_clip. It also adds 'read it back to confirm', indicating an additional return/verification behavior that further clarifies its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives practical guidance: check source resolution first and warns against scaling above 100 on footage that matches the sequence frame, explaining irreversible detail loss. While it doesn't explicitly list alternatives or when not to use, this context is sufficient for most usage decisions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the burden. It does describe the return content in detail, but it does not explicitly state that the operation is read-only or safe, nor does it mention preconditions like requiring an active sequence. For a get tool, this is a minor gap, but it could be improved by noting it has no 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence. It front-loads the key point ('Full picture of the active sequence') followed by a clear list of included data and a usage tip. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and no output schema, the description fully covers what the tool returns and why it is useful. It enumerates all major data categories (timing, effects, Motion scale) and positions it within the workflow, making it complete for an agent to select and invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 documents what is needed. The description adds contextual meaning by explaining the purpose rather than parameter syntax, which satisfies the baseline for no-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves the full timeline of the active sequence, specifying exact data types (resolution, frame rate, duration, clips, effects, Motion scale). This distinguishes it from more specific sibling tools like get_clip, which focuses on individual clips.
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 'The best first call before editing anything' provides clear context on when to use this tool, implying it should precede editing actions. However, it does not explicitly exclude alternative tools or mention when not to use it, but given its role as a comprehensive overview, the guidance is strong.
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?
Without annotations, the description provides useful behavioral details: it scans disk, includes built-in presets, and doesn't require Adobe Media Encoder. This gives the agent context beyond the basic 'list' operation, though it doesn't describe return format or error 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?
Two clear sentences front-load the main purpose and add a practical usage tip. No redundant wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple, and the description covers the core purpose, a key environmental fact (AME not needed), and the connection to export_sequence. Optional parameters are documented in 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?
The schema already describes the 'filter' parameter, and 'limit' is self-explanatory from its constraints. The tool description adds no additional parameter semantics, so it doesn't exceed the baseline for 50% coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
States 'List Adobe .epr export presets on disk' which identifies the exact resource and action. The added detail about including Premiere-shipped presets and referencing export_sequence further clarifies its distinct role among siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage in the export workflow by saying 'Pass the path of one to export_sequence,' indicating when this tool is needed. However, it doesn't explicitly name alternatives or exclusions, so it falls short of fully explicit guidelines.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior. It states that the tool lists all sequences and additionally reports the active sequence, which is a meaningful behavioral detail beyond just 'list sequences'. It does not mention potential side effects, but for a read-only list operation this is acceptable; however, it lacks details on return format or ordering.
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, efficient sentence that conveys both the primary action (list sequences) and a key output (active sequence). There is no redundancy or unnecessary information; every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity—no parameters, no output schema, and a straightforward listing operation—the description fully covers what the tool does and what it returns. It is appropriately scoped for the low complexity, and no critical information is missing.
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 accepts zero parameters, and the schema properties are empty (100% coverage by default). The baseline for 0-parameter tools is 4, and the description correctly avoids adding unnecessary parameter details. It adds no parameter semantics because none exist.
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 'List' and identifies the resource 'every sequence in the project' while also adding the unique outcome of indicating which sequence is active. This clearly distinguishes it from sibling tools like list_project_items, which focus on media items rather than sequences.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for retrieving all sequences and the active one, but it does not explicitly state when to use this tool over alternatives (e.g., set_active_sequence) or mention any exclusions. The context of a read-only listing is clear, but explicit guidance is absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behavioral details: disabled clips remain on the timeline and are skipped in playback/export, emphasizing safety. It does not mention re-enabling or other edge cases, but for a simple toggle it is sufficiently transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, perfectly sized sentence that front-loads the action and then explains the behavioral nuance. Every word earns its place with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter tool with no output schema and no annotations, the description covers purpose, behavior, and usage guidance effectively. It fully equips an agent to decide when and how to invoke the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with both parameters (node_id and enabled) already well described in the schema. The description adds no extra parameter-level detail, but it does reinforce the meaning of 'enabled' via 'Enable or disable,' so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Enable or disable a clip') and the specific resource, distinguishing it from sibling tools like remove_clip and split_clip. The scope is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use it: 'safe way to try removing a shot' contrasts with deletion, giving context for temporary hiding. However, it does not explicitly name alternative tools like remove_clip or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses destructive overwrite behavior, insert semantics, and a confirmation check. However, it omits other potential side effects like track creation or permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the core action. The phrase 'confirm the clip count grew' is a behavior detail but not excessive. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema or annotations, but the description gives purpose, mode behavior, and a prerequisite for item_id. It lacks context about needing an active sequence or handling invalid track indices, but is adequate for a simple tool.
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 covers 60% of parameters with descriptions. The description adds meaning by explaining mode behavior beyond the enum names and suggesting list_project_items for item_id. It does not address track_type or time_seconds 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 clearly states the tool's action: 'Place a project item onto a track at a given time' and adds a verification step. This distinguishes it from siblings like move_clip or remove_clip.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context for the two modes ('Overwrite replaces whatever is already there; insert pushes later clips further down the track') and directs users to list_project_items for the item ID, but does not explicitly mention when to use this tool over alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of disclosing behavior. The verb 'Read' clearly signals a non-mutating operation, and the scope ('every graded clip') clarifies what data is returned. It doesn't describe the return format or edge cases, but for a zero-parameter read operation, it's adequately transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that is front-loaded with the main action and includes a purpose clause. Every word earns its place, no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read tool with no output schema, the description provides the core purpose, usage context, and scope. It doesn't detail the exact return structure, but that's not necessary given the simplicity; the description is complete enough for an agent to select and invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and the schema is empty, so the baseline is 4. The description adds contextual meaning by explaining what will be fetched, which is especially useful given no parameters to document.
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 'Read' to identify this as a retrieval operation, names the resource ('Lumetri Basic Correction values of every graded clip'), and notes the batch nature ('in one call'). This clearly differentiates it from per-clip getters like get_clip.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool: to compare grades across shots without inspecting clips one at a time. It implies an alternative (per-clip inspection) though it doesn't name the specific sibling tool or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden for behavioral disclosure. It clearly signals a read-only enumeration of effect names and adds the context that results are meant for exact naming in apply_effect. It does not detail output format or potential size, but for a simple list tool the behavior is adequately transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the core action and followed by a direct usage pointer. Every word adds value with no repetition of schema details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no output schema, the description clearly implies the return value (a list of effect names) and gives enough context about its relationship to apply_effect. It might benefit from noting optional filters, but the schema already covers that, so the completeness is strong.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% with only 'filter' described. The description adds meaning by explaining 'video or audio' for the kind parameter, and the filter parameter is already described in the schema. This compensation justifies above-baseline scoring.
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 ('List') and a clear resource ('every video or audio effect name Premiere can apply'), and it explicitly ties to apply_effect, distinguishing it from siblings like list_transitions and apply_effect.
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?
It states a clear use case: 'Use this to get exact names for apply_effect.' This provides strong when-to-use guidance. However, it does not mention when not to use it or name alternatives, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses key behavioral aspects: encoder choice, long-running nature, and success only after file confirmation. This goes beyond minimal requirements, though it doesn't mention side effects or permissions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each delivering distinct value: the action, the performance caveat, and the success guarantee. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For an export tool with no output schema, the description is complete: it explains purpose, execution time, timeout requirement, and success condition. No additional information is necessary for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds meaningful guidance on timeout_ms ('raise timeout_ms for big sequences') and clarifies output_path validation ('output file is confirmed on disk'), enhancing parameter understanding beyond schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Render the active sequence to a file', using a specific verb and resource. It distinguishes itself from siblings like export_frame and save_project by specifying sequence-level rendering.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides context that it uses Premiere's own encoder and that it is long-running, with advice to raise timeout_ms for large sequences. While it doesn't explicitly name alternative tools to use instead, the context sufficiently guides when to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the scope (every marker on active sequence) and the fields included, implying a read-only operation. It could additionally specify the return type or behavior with no markers, but for a simple list this is 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?
Single sentence, front-loaded with the verb and resource, no filler. Every word contributes to clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only list tool, the description fully conveys what the tool does and even previews output fields. No output schema exists, but the description suffices.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so the schema coverage is trivially 100%. The description adds no parameter information, but none is needed; baseline for zero parameters is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (list), the resource (every marker on the active sequence), and the returned fields (time, name, comment). This distinguishes it from sibling tools like add_marker and delete_marker.
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 implicitly indicates this tool is for inspecting markers on the currently active sequence, providing clear context. It does not explicitly state when not to use it or compare it to alternatives, but there are no direct competing list tools.
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?
Without annotations, the description carries the full burden of behavioral disclosure. It explicitly warns that 'Any existing volume keyframes on the clip are cleared first,' which is a significant non-obvious behavior. It also mentions the 0 dB ceiling. However, it does not disclose permissions, reversibility, or the return format for the 'read it back' promise.
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 three sentences, each earning its place: a clear statement of purpose, practical dB guidance, and an important keyframe warning. It is front-loaded with the verb and resource, with no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (2 params, no output schema, no annotations), the description is complete. It covers the action, the parameter semantics, and the critical side effect of clearing keyframes. It does not need to explain return values since no output schema is present, and the 'read it back' hint is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, but the description adds beyond the schema by explaining dB semantics: '0 dB is unity and the practical ceiling' and typical values for dialogue and music. This gives meaning to the 'db' parameter that the schema's own description ('0 = unity gain') does not fully convey.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Set a clip's audio level in decibels and read it back,' which uses a specific verb and resource, clearly stating the tool's function. It also distinguishes itself from siblings by focusing on audio level, and no other sibling tool covers this exact operation.
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 provides practical guidance on typical dB values (dialogue near -14 dB, music bed around -26 dB), which helps the agent understand when to use this tool. However, it does not explicitly mention alternatives or exclusions, though the sibling list contains no other audio-level tool, making the use case clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It highlights a critical behavior: 'Premiere will NOT re-analyse from a script' and explains that the response indicates whether the Analyze button still needs to be clicked. This is valuable operational context beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action and mode options, followed by a crucial behavioral caveat. Every word earns its place, with no redundancy or irrelevant details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (3 params, no output schema, no annotations), the description covers the main modes and the behavioral nuance about analysis. It does not mention max_scale or the specific return format beyond the Analyze guidance, but the description is sufficient for an agent to invoke the tool correctly for the core use case.
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 substantial meaning to the 'mode' parameter by explaining the real-world intent of each enum value, which the schema only lists as strings. The node_id and max_scale parameters are already documented in the schema, so the description's focus on mode fills the main semantic gap. However, it does not mention max_scale, leaving that parameter's purpose solely to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool 'Set Warp Stabilizer' and distinguishes the two modes ('no_motion' vs 'smooth_motion') with clear definitions. This makes the purpose unmistakable and differentiates it from sibling tools like get_stabilizer_status, which only retrieves status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use each mode: 'no_motion' for static-camera edits and 'smooth_motion' for maintaining camera movement. However, it does not explicitly mention alternatives or exclusions, such as when to use get_stabilizer_status instead, so it stops short of full exclusion guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility. It discloses a critical behavioral nuance: `solved: false` means the clip is not actually stabilised regardless of settings, and that scripted changes don't trigger re-analysis. This is exactly the kind of non-obvious behavior an agent needs to know.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, each earning its place: what it does, how to interpret a key field, and an actionable warning. Perfectly front-loaded with the purpose, no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description explains the most important field (`solved`) and the re-analysis caveat, making the tool's output understandable. For a simple no-param getter, this is complete and sufficient for an agent to use it and interpret results.
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 baseline is 4. There are no parameters to explain, and the description doesn't need to add any.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb 'Report' and clearly identifies the resource ('Warp Stabilizer state') and scope ('every clip that has it'). It distinguishes itself from sibling tools like set_stabilizer_mode, which modifies state, and get_clip, which retrieves clip metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use guidance: 'Always check this after changing stabiliser settings' and explains the reason ('scripted changes do not trigger re-analysis'). It doesn't explicitly name alternative tools or state when not to use it, but the context is clear enough for an agent to apply correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the tool's read-only nature ('Check... Returns...') and specifies the return payload (version, project name, active sequence). It doesn't detail failure behavior when Premiere isn't running, but for a simple ping this is 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?
Two sentences, zero wasted words. The first sentence states the action and the second provides the return value and usage priority. Ideal structure for a health check tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple tool with no parameters and no output schema. The description covers its purpose, return values, and usage context ('before anything else'), making it fully self-sufficient. No gaps remain for an agent to guess.
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 has zero parameters, so the baseline is 4. The description adds no parameter details, but none are needed. It also explains the primary output, which is the relevant semantic content for a no-argument tool.
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?
Clearly states a specific verb+resource: checks Premiere runtime and bridge panel liveness, and lists return values. This distinguishes it from sibling tools like get_clip or export_sequence, which perform media operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to 'Call this before anything else,' establishing it as a prerequisite health check. This gives clear when-to-use guidance, though it doesn't explicitly mention alternatives (which aren't needed for a ping tool).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the important behavior that no auto-save exists, making this tool the only persistence point after edits. It does not mention potential failure modes or whether saving blocks, but for a simple save operation this is meaningful additional context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the action ('Save the current project'), and the second sentence provides critical usage guidance. Every word earns its place, with no unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (no parameters, no output schema, no annotations), the description is complete. It states both the action and the crucial context of when to call it, which is sufficient for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline score is 4. The description correctly adds no parameter-specific details because there are none to document.
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 'Save the current project' with a specific verb and resource. It is distinct from all sibling tools, which are editing or query operations, so there is no ambiguity about what this tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Nothing auto-saves, so call this after a batch of edits' explicitly advises when to use the tool. This provides clear context and a direct trigger for invocation, even though no alternative save tool exists.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully carries the behavioral disclosure burden. It explicitly states that existing keyframes on the property are cleared first, a destructive side effect, and explains the source-time offset issue. These are critical transparency elements that go beyond basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the primary action. Each sentence earns its place: the first states what it does, the second explains the keyframe clearing rationale, and the third addresses a subtle edge case. No wasted words or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is remarkably complete for a tool with 3 parameters and no output schema. It covers the operation, the side effect on existing keyframes, and the source-time offset handling. There are no significant gaps in understanding how the tool behaves and how it interacts with clip state.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, providing baseline 3. The description adds meaning by connecting fade parameters to opacity/volume and explaining why they work correctly given keyframe clearing and source-time offsets. This enriches understanding beyond the schema's simple descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's function with a specific verb and resource: 'Put a clean fade in and/or out on a clip.' It further specifies the affected properties (Opacity for video, Volume for audio), which distinguishes it from other audio/video adjustment tools like set_audio_level or set_scale.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool by explaining why it's superior to naive keyframing: it clears existing keyframes and handles source-time offsets. This gives clear context for appropriate use, though it doesn't explicitly name alternatives or state 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.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full responsibility for disclosing side effects. It explicitly warns that the operation is destructive and details what ripple does (closes gap, shifts content) versus lift (leaves a 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 extremely compact—two sentences that front-load the core purpose, then clarify behavior and provide a safety reminder. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive edit tool, it covers the essential aspects: what it does, how each mode behaves, the safety caveat, and a recommended workflow (verify with get_timeline). No output schema is needed for a removal action.
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 covers both parameters with descriptions, so baseline is 3. The description adds meaningful behavioral context to the 'ripple' parameter by explaining its effect on the timeline, and underscores the importance of node_id with the destructive warning.
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?
Clearly states 'Remove a clip from the timeline' with a specific verb and resource. The ripple vs. lift distinction further differentiates it from sibling tools like move_clip or trim_clip.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Directs the user to confirm the node ID with get_timeline first, naming a specific alternative tool for verification. It also explains the two operational modes (ripple vs. lift), clarifying when to choose each behavior.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![adobe-premiere-cc-mcp MCP server](https://glama.ai/mcp/servers/MarvelCollin/adobe-premiere-cc-mcp/badges/card.svg)](https://glama.ai/mcp/servers/MarvelCollin/adobe-premiere-cc-mcp)

Score Badge

Copy to your README.md:

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

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