Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description bears the full disclosure burden. It usefully explains the default placement (start frame when frame_id is omitted), but says nothing about persistence, required state/permissions, whether the marker is selected after creation, or what is returned.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One short sentence, front-loaded with the action, and the parenthetical default is immediately useful. No wasted words, though the brevity is partly the source of the coverage gaps.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 5-parameter mutation tool with no annotations and no output schema, the description is too thin: only the frame_id default is covered, leaving required state and the meaning of four parameters unexplained.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must explain the 5 parameters. It only clarifies frame_id's null default; name, note, color and duration are left entirely undocumented, including what a 'duration' of 1 means.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (add) plus resource (marker) and the target scope (the active timeline). It is clearly distinguishable from get_markers and delete_marker, though it doesn't explicitly name those siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

'Active timeline' implies a prerequisite (a timeline must be current) and nudges toward set_current_timeline workflows, but the description never states when to use this versus alternatives or what happens if no timeline is active.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and falls short. It doesn't state whether creation mutates the current project, whether names must be unique, what happens on duplicates, or what the call returns.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, front-loaded sentence with zero filler; efficient in size. The brevity edges into under-specification rather than verbosity, but nothing in the sentence is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and an undocumented parameter, the description is far too sparse. It omits prerequisites, side effects, and return behavior that an agent needs before calling it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter has 0% schema description coverage, so the description must compensate, but it never mentions 'name'. The meaning of the parameter (the bin's label) is only inferable from the tool name, not stated.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Create a Media Pool bin') so the action is unambiguous. No sibling tool also creates bins, but the description never explains what a Media Pool bin is or its relation to a loaded project, leaving differentiation implicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no indication of when to use this versus alternatives, no prerequisite (e.g., whether a project must be loaded first), and no exclusion conditions. The agent must infer all usage context from the name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden of behavioral disclosure. It says nothing about persistence, whether an existing project with the same name is rejected or overwritten, required permissions, or side effects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One sentence with no redundancy, but this is under-specification rather than conciseness. Nothing is front-loaded beyond the already-obvious purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

A mutation tool with zero annotations, no output schema, and 0% parameter coverage needs far more description. As written, an agent cannot predict the return value, error conditions, or the effect of a duplicate name.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% for the single required 'name' parameter. The description does not clarify whether the name is a display name, a unique identifier, or whether it must be unique — leaving the only parameter's semantics undefined.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description restates the tool name almost verbatim ('Create a new project' for create_project), adding no scope, target system, or object type. It does not distinguish this from save_project or create_timeline among the siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No indication of when to use this versus save_project, load_project, or list_projects. The agent must infer that this creates a brand-new persisted project rather than saving an in-memory state.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and covers little: it does not say whether the new timeline becomes the current timeline (a real question given the sibling set_current_timeline), what happens to existing timelines, what the call returns, or whether the timeline persists until saved.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One short, front-loaded sentence with no wasted words. Brevity here reflects under-specification rather than tight craft, but structurally it is clean.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a creation tool with no annotations, no output schema, and an undocumented parameter, the description omits essentials: the creation's side effects, whether it becomes active, and how to reference the new timeline afterwards. Materially incomplete for an agent deciding how to call it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0% and the single 'name' parameter is never mentioned in the description, so the agent gets no signal that it is optional or what happens if it is omitted (auto-generated name?). The description fails to compensate for the documentation gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Create an empty timeline') and scopes it to the current project, which separates it from get_timelines and create_bin. It does not explicitly name a sibling or clarify how it relates to create_project, but the action is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No when-to-use guidance, no prerequisites stated, and no alternatives named. The phrase 'in the current project' hints that a project must be loaded first, but that is inference rather than instruction; nothing says when to prefer this over create_project or set_current_timeline.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden for a mutation tool. It never says whether the deletion is permanent, whether it errors when no marker exists at that frame, what happens if multiple markers share a frame, or whether any permission is required.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler, so nothing is wasteful. The brevity is a liability for specification rather than an efficiency win, which keeps it from a 5.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a one-parameter destructive tool with no annotations and no output schema, the description should at least resolve the marker-identity question and the failure mode. As written, the agent cannot tell what a successful call looks like or what state it must supply beyond a raw integer.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for frame_id and does not. 'At a frame' loosely implies frame_id identifies a frame, but it never clarifies whether that is a timeline frame number, a position, or whether a frame uniquely identifies a marker when several markers could sit at the same frame.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb (Delete) and resource (the marker) with a scope hint (at a frame), so the agent knows exactly what operation is performed. It does not differentiate from the obvious siblings add_marker and get_markers, so it falls short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this versus add_marker or get_markers, nor any precondition such as the marker having to exist first. The agent must infer the entire usage context from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the full burden. It does scope the read to the 'active timeline', but says nothing about failure behavior when no timeline is active, nor whether the returned value is a formatted timecode string or a frame count.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence with no filler, and the key qualifier ('active timeline') is present rather than buried.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description should specify the return shape and the no-active-timeline case. It hints at 'timecode' but leaves an agent guessing about format and error conditions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies the call is parameterless.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Get') and resource ('playhead timecode of the active timeline'), which is precise enough to distinguish it from the setter sibling set_current_time. It does not name any sibling explicitly, so it stops short of a 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent can infer this is the read counterpart to set_current_time, but the description never says when to call it versus set_current_time or get_timelines, and gives no preconditions (e.g., that a project/timeline must be loaded).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden, yet it discloses almost nothing: it doesn't confirm the operation is read-only, whether it paginates, what happens with no active timeline, or what a marker contains. Only the word 'active' hints at state dependency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The single sentence is short but under-specified rather than concise—it spends its one clause on a phrase ('active timeline') that raises more questions than it answers and front-loads nothing useful about output or state.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a no-param, undocumented, annotation-free read tool, the description should at least state the return shape (list of markers?), the read-only nature, and the active-timeline precondition. None of that is present, and there is no output schema to lean on.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has zero parameters, so there is nothing to document; baseline for a 0-param tool is 4. The description doesn't need to compensate, though it also doesn't clarify that no arguments are accepted.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a verb and resource (get markers) and adds scope ('on the active timeline'), which distinguishes it somewhat from add_marker/delete_marker. However, 'markers' is never defined and the phrasing barely exceeds restating the tool name, so it is only marginally better than tautology.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no explicit when-to-use guidance and no named alternatives. The phrase 'active timeline' implies a dependency on set_current_timeline/load_project, but the agent must infer that; nothing tells it when to prefer this over other timeline reads or what to do if no timeline is active.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the full behavioral burden, and it discloses almost nothing: it does not say whether the result is a boolean, a status object, or what happens when no render has ever been started. It also omits whether this is a cheap read-safe poll suitable for repeated calls, which matters for a status-checking tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single short sentence with the key concept front-loaded and no filler. Nothing could be removed without losing meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description is the only source of truth about behavior, and it leaves the return shape entirely undefined. An agent cannot tell whether to expect a boolean, a percentage, or a structured render object, which is a significant gap for a status-query tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is no parameter semantics to explain and the schema cannot be improved upon. Baseline 4 applies; no misleading parameter hints are introduced.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('check') and resource ('render status'), and the phrasing 'in progress' scopes it to active renders, which distinguishes it from start_render and stop_render. It does not, however, distinguish it from the sibling get_status, which could plausibly overlap.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent can infer it should be called to poll render progress, but the description never states when to call it, whether it should be polled, or how it relates to get_status or stop_render. No explicit alternatives or exclusions are given.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations, so the description carries the burden. It is clearly a read of host state with no parameters and no apparent side effects, but it never states that it is read-only or what happens if Resolve isn't running (error vs. partial result).

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One front-loaded sentence with no filler; the field list is the useful content. Slightly terse for a tool with no output schema, but nothing is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no output schema and no annotations, the description compensates by enumerating what is returned (version, page, project, timeline). The only meaningful omission is failure behavior when Resolve is unavailable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Zero parameters, so the baseline is 4. Nothing in the description is needed for argument formation, and the schema fully covers the (empty) argument object.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Specific verb ('Get') plus an enumerated set of resources: app version, current page, open project, active timeline. That distinguishes it from narrower siblings like get_timelines and list_projects, though it doesn't name the alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit when-to-use statement, no exclusion of siblings such as ping (health check) or get_current_time. Usage is implied by the returned field list – a general state snapshot – but the agent must infer it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden, yet it only discloses the project scoping. It does not say whether it is read-only (implied only by "List"), how it behaves with no current project, whether the active timeline is flagged, or anything about ordering or pagination.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with zero filler. The scoping constraint comes immediately after the verb+resource, so the key information lands first.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple zero-parameter, read-only tool this covers the basics, but with no output schema and no annotations the description should say what a timeline entry looks like (id/name) and whether the current timeline is marked. That gap is the only meaningful omission.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The only semantic element, the implicit "current project" context, is stated.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource ("List all timelines") plus the scope ("in the current project"), so an agent immediately knows this is a read of project-scoped timelines, distinct from create_timeline or set_current_timeline. It stops short of explicitly naming those siblings as alternatives.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: the "current project" scope hints that a project must be loaded first and that this is the enumeration counterpart to create_timeline. There is no explicit when-to-use/when-not or named alternative.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It implies a write operation to the Media Pool but does not disclose side effects, duplicate handling, supported formats, permissions, or failure behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single efficient sentence with the key operation and path constraint front-loaded. There is no wasted text, though the brevity leaves important details unstated.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For an import tool with no annotations and no output schema, the definition is too thin. An agent lacks guidance on prerequisites, supported media types, duplicate handling, and what the import operation returns or changes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, but the description adds useful meaning by stating that paths must be absolute media file paths. It does not explain the array nature, multiple-file behavior, or supported file types beyond that.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: import media files into the Media Pool. This clearly identifies the operation, though it does not explicitly differentiate from any sibling tool because no direct import alternative exists.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives only a parenthetical note that paths must be absolute, with no guidance on when to use this tool versus alternatives. It does not mention prerequisites such as having a project open or a target bin selected.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. "List" implies a read-only, non-destructive call, but nothing states side effects, permission requirements, whether results include archived/closed projects, or whether the listing is recursive across subfolders.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no waste. It is arguably too terse rather than padded — the brevity leaves gaps, but no sentence is filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-param list tool with no output schema, the description should say at least what a list entry looks like or how the result is ordered/limited. It establishes scope but leaves the return shape entirely undocumented.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the schema baseline is 4. The description does add a small amount of meaning by anchoring the result set to "the current database folder," implying the scope comes from external state rather than arguments.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Specific verb plus resource ("List projects") with a scoping qualifier ("in the current database folder"), which distinguishes it from mutating siblings like create_project, save_project, and load_project. It stops short of naming an alternative or clarifying how it relates to get_status or the load/save family.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no when-to-use or when-not-to-use guidance, no mention of prerequisites, and no routing to siblings such as get_status (which may also expose project context). The agent must infer that this is the discovery step before load_project.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It does not disclose whether loading changes global state (e.g., a 'current project'), what happens if the name doesn't match, whether it is read-only, or what the return value is. For a state-affecting tool this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single short sentence, front-loaded with the verb and resource, with no filler. There is nothing to trim.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations and no output schema, the description should explain the effect of loading and the likely failure mode (unknown name). Neither is present, so an agent cannot predict side effects or return behavior before calling.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. "By name" clarifies that the identifier is a name rather than an ID, but it gives no detail on exact-match rules, case sensitivity, or format, leaving the sole parameter's semantics thin.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ("Load an existing project"), making the action unambiguous. It does not differentiate itself from siblings like create_project or list_projects, nor does it explain what "load" implies operationally.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The word "existing" weakly implies this is not for creating projects, but there is no explicit guidance on when to use this versus list_projects (to find the name) or create_project (if it doesn't exist). No prerequisites, ordering, or failure conditions are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and only says 'switch'. It doesn't state whether a project must be loaded first, whether the switch is reversible, what happens on an invalid page name, or whether state is lost. Only the mutation-by-implication of 'switch' is conveyed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One short sentence, front-loaded with the verb and resource, with the value list appended. No filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a single-parameter navigation tool with no output schema, the description covers the essentials of what to pass. It is still missing preconditions (project loaded?) and error behavior, which matter for an agent sequencing calls across the many project/timeline siblings.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% and there is no enum, so the description must compensate; it does list the seven valid page names, which is the single most valuable piece of parameter information. However, it doesn't confirm exact casing/string format or whether other values are accepted, so the compensation is partial.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Specific verb ('Switch') plus resource ('page') with the full set of valid page names enumerated, so an agent knows exactly what the tool does. It is clearly distinct from siblings like get_status or start_render, though it doesn't explicitly say it's a UI-navigation action.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: the enumeration of pages suggests the tool is for moving between application workspaces. There is no statement of when to use it (e.g., before adding a marker or after loading a project) and no exclusions, but no sibling competes for the same job, so the gap is modest.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden, and it discloses only that the call verifies bridge liveness. It says nothing about what happens when the bridge is down (error vs. falsy result), latency, or whether the call has side effects — modest but incomplete disclosure for a health check.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One short sentence, zero filler, with the verification intent front-loaded. Nothing could be removed without losing meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a trivial zero-param probe this is nearly sufficient, but with no output schema the agent still cannot tell what a successful versus failed check returns. One clause on the response shape would make it complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the baseline is 4; there is nothing for the description to disambiguate. No parameter-level information is missing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Check') and a specific resource (the bridge running inside DaVinci Resolve), so the agent knows this is a liveness probe. It does not distinguish itself from the sibling get_status, which an agent could reasonably pick instead for the same intent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: an agent infers this is the first call to verify connectivity before real work. There is no explicit statement of when to prefer this over get_status, nor any precondition or follow-up guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure for a mutation tool. It does not say whether the save overwrites, whether it is reversible, what happens if no project is open, or whether it returns a path/status — all of which an agent needs before invoking a write operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler. It is appropriately short for a zero-parameter action, though the terseness borders on under-specification rather than optimal economy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a trivial zero-param tool the description is minimally adequate, but with no annotations and no output schema the agent still lacks the failure mode (no open project) and the result of the save. Slightly more context would round it out.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing for the description to clarify; the schema is empty and complete. Baseline 4 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

Clear verb ('Save') plus a specific resource ('the currently open project'), which distinguishes it from create_project and load_project in the sibling list. It does not, however, state what saving entails (persist to disk, overwrite existing file, autosave vs explicit).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is only implied: 'currently open project' suggests a project must first be loaded via load_project/open_page, but the description never says when to call it or what alternative exists (e.g. create_project for a new one). No exclusions or prerequisites are stated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden, but it only says 'Move the playhead.' It does not disclose whether this requires an active timeline, whether the timecode must be within project bounds, or what happens if the timecode is invalid.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single front-loaded sentence with no padding. It is appropriately sized for a simple setter, though the terseness leaves behavioral gaps that a slightly richer sentence could address.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a mutation tool with no annotations, no output schema, and an undocumented parameter, the description is too thin. It gives an example timecode but omits required context such as active-timeline assumptions and the effect of moving the playhead.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description should compensate. The example '01:00:10:00' usefully demonstrates the HH:MM:SS:FF timecode format, but it does not describe frame-rate or drop-frame handling, bounds, or other constraints on the single timecode parameter.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action and target: moving the playhead. This is clear for a video-editing context, though it does not explicitly contrast with the sibling get_current_time. The example timecode clarifies the intent is to set the current position, not read it.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

There is no guidance on when to use this versus get_current_time or set_current_timeline. No prerequisites or exclusions are stated, leaving the agent to infer that an active timeline/project is required.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden, and it discloses almost nothing: not whether activation persists, what happens on an invalid name/index, or which parameter wins if both are given. 'Activate' implies a state change but none of its side effects or failure modes are described.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single efficient sentence with the key selection modes front-loaded and no filler. It is appropriately terse, though the terseness leaves the gaps above unaddressed.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations, no output schema, and zero schema description coverage on two optional params, this mutation-style tool needs considerably more detail than one line to be called confidently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% and both parameters are optional, yet the description only adds the useful '1-based' detail for index. It never resolves the critical ambiguity of mutual exclusivity or what happens when both name and index are supplied or omitted.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb ('Activate') and resource ('timeline') plus the two ways to select one. It is distinguishable from create_timeline and get_timelines, though it never names those siblings explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No statement of when to prefer this over create_timeline or get_timelines, and no prerequisite noted (e.g. that the project must be open or the timeline must already exist). At best the 'by name or index' phrasing weakly implies you should already know the identifier.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not explain whether the operation is blocking or asynchronous, what happens if rendering is already in progress, whether special permissions are required, or what the tool returns. It only restates the action, leaving significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no wasted words. It communicates the core action immediately and does not bury the purpose in unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter action tool, the description states the basic operation but omits important context such as expected state, side effects, and return behavior. With no annotations and no output schema, the description should do more to prepare the agent for possible edge cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so the baseline score is 4. There are no parameter semantics to document, and the description appropriately does not invent any.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific action ('Start rendering') and object ('the current render queue'), making the core purpose clear. It does not explicitly differentiate itself from siblings such as stop_render or get_render_status, but the verb and resource are specific enough for an agent to identify the tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description offers no explicit guidance on when to use this tool versus alternatives like stop_render or get_render_status. It does not state prerequisites such as needing a non-empty queue, nor does it mention conditions under which rendering should not be started.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden for a state-changing operation. It does not disclose whether a partially written output file is kept or discarded, whether the call errors or no-ops when nothing is rendering, 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.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single front-loaded sentence with no filler, which is appropriate in size for the amount of information given. It is terse to the point of omitting behavioral detail, but not padded or repetitive.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With no annotations, no output schema, and no parameters, the description is the only source of behavioral information and it provides just five words. An agent still cannot tell what the call returns, whether it can fail, or what happens to in-progress render output.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool takes zero parameters, so there is nothing beyond the schema to document; the baseline of 4 applies. No misleading parameter information is present.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('Stop the active render'), which clearly distinguishes it from start_render and get_render_status among the siblings. It is unambiguous but does not explicitly name the alternatives it contrasts with.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The word 'active' implies it applies to a currently running render, which gives implicit usage context. It does not state what happens if no render is active or direct the agent to get_render_status to confirm state first.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.