kimo

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

No annotations are provided, so the description carries the full disclosure burden and delivers none of it. With 32 hidden actions, it is unknown whether calls mutate the project, require a selection, or are irreversible, and no auth, rate, or side-effect information is given.

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?

It is short, but brevity here reflects under-specification rather than economy of expression. The truncated ellipsis list front-loads topics instead of the operation, so a reader gets no actionable payload from the sentence.

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 32-action dispatcher with 0% schema documentation, no annotations, and no output schema requires far more description than this. Nothing tells the agent how to select one of the 32 actions or what a call returns, leaving the definition unusable without trial and error.

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 both parameters: 'action' is a bare string with no enumerated values and 'args' is an untyped free-form object. The description only discloses the count ('[32 actions]') and the topical buckets, which hints at the action space but names no valid action value or arg shape.

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 text is a topic list ('Properties, keyframes and curves, expressions, motion paths...') with no verb and no statement of what the tool actually does. It gestures at the animation domain, which tentatively separates it from siblings like color_grade or audio, but an agent cannot tell from this whether the tool reads, creates, edits, or applies animation data.

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 instruction, no prerequisite, and no named alternative among the many siblings. The only implicit signal is the subject-matter list, which suggests this is the tool for animation questions, but nothing tells the agent when to prefer it over timeline or effects.

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. The bracketed '[17 actions]' does hint that this is a multi-action dispatcher, but the description says nothing about which actions mutate or destroy data (normalize, ducking), which are read-only (levels, beat detection), or whether audio export writes files — critical for a tool whose domain includes destructive edits.

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 line with no filler; the capability list is dense and scannable. It is efficient, though the list substitutes for the action enumeration an agent actually needs.

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 17-action dispatcher with an unenumerated free-form 'action' string, an untyped 'args' object, no annotations, and no output schema, the description is grossly insufficient — an agent cannot reliably determine a valid action value or argument shape before invoking.

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 two parameters ('action' string with no enum, 'args' as a bare untyped object) are entirely undocumented. The description's topic keywords ('pan', 'ducking', 'normalize', 'beat detection', 'export') give a faint hint at the action space but provide no mapping to valid 'action' values and no shape for 'args'.

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 names the resource domain (audio) and enumerates capability areas — levels, pan, ducking, normalize, beat detection, export — which distinguishes it from siblings like color_grade, masks, or vfx3d. However, it never states a verb or the actual operation the tool performs, and the '[17 actions]' marker signals a dispatcher whose action names are not listed, so the agent cannot tell what a call concretely does.

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 statement of when to use this tool versus alternatives, no prerequisites, and no exclusions. The capability list only weakly implies usage contexts (e.g., 'export' implies a finishing step), but the agent gets no guidance on choosing this over the separate 'effects' or 'output' siblings.

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 nothing: not whether operations mutate the project, whether they are reversible, whether node graph or LUT changes persist, or what permissions are needed. For a mutation-oriented grading tool this is a total transparency 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?

It is short, but brevity here is under-specification rather than conciseness: the '[22 actions]' ellipsis replaces information the agent needs. The front-loaded 'Grading:' label is the one structurally sound element.

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 22-action dispatcher with a freeform nested args object, no annotations, no output schema, and no enum is a high-complexity surface, and the description supplies only a keyword stub. It is far below what an agent needs to invoke the right action with the right arguments.

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 'action' is a bare string with no enum, so the partial action list in the description is the only hint at valid values – but it shows roughly 9 of 22 actions and never explains the nested 'args' object. The agent is left guessing both the action vocabulary and its payload shape.

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 colon-list identifies the domain (color grading) and enumerates sub-operations – primaries, curves, wheels, node graphs, LUTs, CDL, match grade, white balance, shared – which is enough to distinguish it from color_science and scopes siblings. However there is no explicit verb framing, and the enumeration is truncated to a generic '[22 actions]' placeholder, so the actual scope is only partially visible.

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 about when to use this tool rather than color_science, scopes, or effects, and no prerequisites or exclusions. The agent must infer that grading work belongs here purely from the word 'Grading'.

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 discloses almost nothing: no indication that action values trigger wildly different (potentially mutating) behaviors, no side effects, no permission/render requirements. The only signal is the passing mention of 'delivery checks', which is insufficient for an untyped multi-action dispatcher.

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?

It is short, but 'and... [18 actions]' is a truncated fragment rather than a front-loaded summary, so brevity comes from omission rather than economy. There is no lead sentence establishing what the tool does before listing topics.

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 2-parameter multiplexed tool with 0% schema coverage, no enums, no annotations, and no output schema, the description omits everything an agent needs: which actions exist, what they do, and what args to pass. It is not remotely complete for the complexity of the interface.

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 there are 2 parameters (a required opaque 'action' string plus a nested 'args' object). The description provides no valid action names, value syntax, or meaning for args, so an agent cannot fill in the parameters without external knowledge. Zero compensation for a 0% coverage schema.

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 is a topic enumeration (ACES, OCIO, HDR, float/bit depth, delivery checks) with no verb or statement of what the tool actually does. It hints at the color domain but never says 'grade', 'convert', 'validate', or similar, so an agent cannot form a clear purpose from it. It is closer to restating the name's theme than stating a capability.

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 guidance, no exclusions, and no reference to alternatives even though siblings like color_grade and scopes clearly overlap in this space. The elided '[18 actions]' gives no routing information for choosing among them. This is effectively no 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 behavioral burden, and it discloses almost nothing beyond the domain list. It does not say whether actions mutate the project, whether they are reversible, what permissions are needed, or how errors surface for an unknown action.

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 text is short and the domain list is front-loaded, which is good, but this reads as under-specification rather than genuine concision. The bracketed action count is a useful hook that is never followed through.

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 15-action multiplexed tool with no annotations, no output schema, an undocumented nested args object, and zero schema description coverage, the description is far too thin. An agent has no basis for choosing an action value or shaping the args payload.

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 required 'action' string has no enum, so the agent must guess the 15 valid action names. The description's '[15 actions]' note signals the count but enumerates none of them, and the nested 'args' object is entirely undocumented in both schema and description.

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 enumerates the resource domain (video effects, transitions, adjustment layers, effect masks, presets) and discloses that it is a 15-action dispatcher, but it never states a verb or names any of the 15 actions. It also fails to distinguish itself from overlapping siblings such as masks, vfx3d, and color_grade, so an agent cannot confidently route among them.

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 at all. With siblings like masks, vfx3d, and color_grade plausibly covering adjacent territory, the absence of any routing rule is a real gap rather than a minor omission.

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, and it discloses nothing: no mutation/destructive characteristics, no permission or licensing needs, no indication that this is a multi-action dispatcher requiring a specific action value. The only hint at behavior is the bracketed action count, which is unexplained metadata.

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?

It is short, but brevity here comes from under-specification rather than efficiency, and the dangling "[20 actions]" marker is an artifact rather than useful content. There is no front-loaded verb or scope statement to anchor the list.

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 20-action dispatcher with 0% schema coverage, no enums, a nested args object, and no annotations or output schema is essentially un-callable from this description. An agent would have to guess valid action values and the shape of args entirely.

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 only guidance is the cryptic "[20 actions]" tag; the required action string is never enumerated, so the agent cannot know which of the 20 values are valid. The nested args object is entirely undocumented in both schema and description, leaving no way to construct a correct call.

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 is a bare list of nouns ("Shapes, bezier paths, shape modifiers, layer styles, HUD frames, counters, detection boxes") with no verb and no statement of what the tool actually does. It gives a topical hint that this is the graphics-primitives area, distinct from siblings like text/audio/masks, but an agent cannot tell what operation it performs. The "[20 actions]" tag implies a dispatcher without saying so.

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 guidance, no mention of prerequisites, and no routing help relative to the many siblings (masks, text, effects, vfx3d). An agent gets zero signal on when to pick graphics over an adjacent tool.

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 discloses almost nothing: no indication of read-only safety, return format, authentication needs, or limits. It only implies two lookup modes (action vs group) without stating what each returns in practice.

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 tight, though the parenthetical restatement of the parameter names is mildly redundant with the schema.

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?

No output schema and no annotations, yet the description says little about the returned structure, the meaning of 'group', or valid identifiers. For a discovery/meta tool that an agent depends on to proceed, this leaves substantial gaps.

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. It does clarify that 'action' selects a single action's description+schema while 'group' yields a group's action list, which adds meaning beyond the bare string types. It still does not say whether the two are mutually exclusive, what valid values look like, or what happens if both/neither are supplied.

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 the tool returns a full description/argument schema for an action or the action list for a group, which is a reasonably specific verb+resource. However, it does not differentiate itself from the many sibling tools (e.g. search_tools, kimo_enable_group) that also relate to tool discovery, and the roundabout phrasing 'full description and argument schema of one action' takes effort to parse.

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 call this versus search_tools or kimo_enable_group, nor when to use the action path versus the group path. 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 burden, and it does disclose two real traits: the change persists ('from now on') and the server emits notifications/tools/list_changed. However, it says nothing about reversibility (is there a disable counterpart?), idempotency, or error behavior for an invalid group name.

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 the effect front-loaded and the mechanism in a parenthetical; no filler. Slightly terse given the concepts ('group') it assumes the reader already knows.

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 stateful, side-effecting tool with no annotations, no output schema, and an undocumented required parameter. The description should at minimum define what a 'group' is and how its name is obtained, and note whether the setting can be undone.

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 the single required 'name' parameter has no description. The description only alludes to 'a group', leaving the agent to guess whether name is a group identifier, a display name, or a path.

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 conveys the effect of enabling a group — its tools are listed individually going forward — but the phrasing 'List every tool of a group individually from now on' reads like an instruction to the agent rather than a description of a stateful toggle, so the verb does not match the name 'enable_group'. It is distinguishable from siblings like search_tools, but only indirectly.

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 statement of when to use this versus alternatives such as kimo_describe or search_tools, nor any prerequisite or context for calling it. The agent must infer the trigger condition entirely.

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, yet it discloses nothing about whether operations mutate the project, what permissions or clip selection is required, reversibility, or rate limits. '[16 actions]' signals breadth but hides which 16 actions exist.

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 short and the '[16 actions]' count is front-loaded and informative, but its brevity reflects under-specification rather than efficient conciseness. It omits everything needed to select and invoke a 16-action dispatcher.

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 multi-action tool with a nested, undocumented args object, no action enum, no output schema, and no annotations, the description is far too thin. Nothing explains how the 16 actions are named or dispatched, so the definition cannot be used reliably.

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 both parameters: 'action' is an unconstrained string with no enum, and 'args' is an undescribed nested object. The description adds no information about valid action values or argument shape, so an agent cannot construct a call correctly.

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 text is a noun list of adjacent subtopics (masks, roto, track mattes, matte refinement, keying) with no verb describing what invoking the tool actually does. It partially expands the bare name 'masks' and hints at scope versus siblings like tracking or vfx3d, but gives no indication of the 16 operations it dispatches.

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 statement of when to use this tool, no conditions, and no named alternatives among siblings such as vfx3d, tracking, or effects. The topic list only loosely implies a domain, leaving the agent to guess whether a matte or keying task belongs here.

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. Exporting video/GIF/EXR/TIFF writes files and camera solves are expensive compute-bound operations, but the description says nothing about side effects, output locations, overwrite behavior, processing time, or required project state. Format names add only surface-level context.

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?

It is a single compact fragment with no filler, which is efficient, but the comma-separated feature dump is not front-loaded around the action/args contract and reads as an unordered keyword list rather than structured guidance.

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 40-action dispatcher with a free-form string action, an unbounded nested args object, no annotations, and no output schema, the description is far too thin. It should at minimum enumerate the action identifiers and the required shape of args; without that, correct invocation is guesswork.

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 'action' is an unconstrained string with no enum, while 'args' is an opaque nested object. The description lists some output formats but never enumerates the 40 valid action values or explains how args map to a given action, so an agent cannot construct a correct call from either source.

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 gives verbs and resources ('Render a frame', 'export video') and signals breadth with '[40 actions]', so the agent knows this is a rendering/export dispatcher. However, it never says what a single 'output' call actually does or how the 40 actions divide the space, and the tool name 'output' on its own would be meaningless without it. It is clear enough to categorize but not to distinguish precisely from siblings like 'color_science' or 'vfx3d'.

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 statement of when to use this tool versus siblings (color_grade, vfx3d, project) and no exclusion criteria. '[40 actions]' implies the caller must pick an action, but neither the description nor the schema offers the action list, so no routing guidance is actually provided.

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 entire behavioral burden. It hints that mutations are included (save/load, undo/redo) but never states reversibility, permission requirements, side effects, or which actions are read-only versus destructive. For a 35-action dispatcher with zero annotation coverage, this is a substantial 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?

It is short and front-loaded with the resource name, so it is not bloated. But the enumerated coverage list consumes its length without conveying actionable detail (valid actions, usage), so it reads as under-specification rather than tight concision.

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 dispatcher exposing 35 actions with no enum, no annotations, no output schema, and 0% parameter documentation, the description leaves an agent unable to determine which action strings exist or what any of them do. Almost nothing needed to invoke it correctly is present.

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%, the required 'action' string is a freeform value, and 'args' is an untyped nested object. The description never enumerates or exemplify valid action values, which is the single most important parameter detail for calling this tool. '[35 actions]' acknowledges the gap instead of filling it.

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 names the resource domain ('project') and enumerates broad areas it covers (settings, media import, save/load, undo/redo, inspect), so an agent knows this is the project-level namespace. However, it never states what the tool actually does at the action level, and the '[35 actions]' note flags breadth without resolving it. Differentiation from siblings is only by domain name, not by function.

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 tool versus the many siblings (timeline, effects, audio, etc.), nor on how to select among the 35 actions. The category list implies scope but gives no conditions, prerequisites, or routing advice.

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 hints at analysis (suggesting read-only) by naming measurement capabilities, but never states side effects, whether any of the 12 actions mutate state, permission requirements, or output 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?

It is short and front-loads the domain, which is good. But the trailing ellipsis and bracketed '[12 actions]' placeholder are cryptic filler that do not earn their place by conveying actionable 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 multi-action tool (12 actions), with a required enum-like 'action' string, a nested 'args' object, 0% schema coverage, no annotations, and no output schema, this description is grossly inadequate. It omits the action list, argument shapes, and return behavior an agent needs to invoke it correctly.

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 description provides no parameter information at all. The '[12 actions]' placeholder hints that the required 'action' string has twelve possible values, yet none are listed, and the nested 'args' object is entirely unexplained, so an agent cannot construct a valid call.

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 names the resource domain (scopes/measurement) and lists example capabilities (waveform/vectorscope, exposure, false color, gamut), which distinguishes it somewhat from siblings like color_grade. However, it is a noun-phrase label with no explicit verb and never states what the tool actually does (return measurements? apply corrections?), so the purpose is only implied.

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 guidance, no exclusions, and no mention of alternatives such as color_grade or color_science, which plausibly overlap. The agent must infer usage from the domain 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. It does disclose return behavior ('ranked matches with required args and how to call each'), which is useful and non-obvious. It omits whether results are capped, how ranking works, and what a zero-match response looks like.

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?

Three short sentences with no filler, and the core purpose is front-loaded. Slightly more could be said without bloat, but nothing present 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?

No output schema exists, so the description is right to summarize the return shape, and it does. It remains incomplete on result limits, the group scoping parameter, and the relationship to the sibling tools it is presumably searching.

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 the description only implicitly maps 'keywords' to the required query param. The group and limit parameters are undocumented in both the schema and the description, so neither source tells the agent how to scope a search or control result count.

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 multi-resource scope: 'Find a tool, effect or transition by keywords.' An agent can tell this is a discovery/meta tool distinct from the functional siblings (effects, masks, audio), though it never explicitly says it searches the sibling catalog.

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?

'Call any listed name directly' implies a search-then-invoke workflow, which is genuine guidance. But there is no statement of when to use this versus paging through effects/timeline/kimo_describe directly, and no exclusions or prerequisites.

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 and the description gives no behavioral disclosure: no read/write profile, no side effects, no auth or rate-limit notes, and no indication of what the 23 actions do. For a dispatcher tool with zero annotation coverage, the description carries the full burden and provides none of it.

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 line is short and wastes no words, but its brevity is under-specification rather than efficiency. It lists topics without giving the verb, action set, or parameter meaning, and reads as a flat fragment rather than front-loaded actionable guidance.

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 23-action nested dispatcher with no annotations, no output schema, and 0% schema coverage, the description is far from sufficient. It omits action names, parameter semantics, and return behavior, leaving the agent unable to invoke it correctly.

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 both action and args, and the description only hints that 23 actions exist without naming a single one. It does not document valid action values, the shape of the nested args object, or per-action parameters. An agent cannot construct a correct call from this description.

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 enumerates resource domains (text, titles, captions, fonts, transcription) but supplies no verb or statement of what the tool does to them. It implies a multi-action dispatcher via '[23 actions]' yet an agent cannot tell whether it creates, edits, or queries text. It is distinguishable from siblings only by topic, not by function.

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 guidance, no alternatives, and no mention of the action parameter or when to choose this over graphics, animate, or effects. The agent is left to infer usage entirely from the domain list.

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 discloses nothing. It does not say that actions like add/move/trim/split are destructive edits, whether they are undoable, whether any action is read-only, or what state the tool requires. The '[37 actions]' note is a structural hint, not behavioral context.

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

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

It is a single short line, which is efficient, but it is a fragment rather than a front-loaded purpose statement, and the trailing ellipsis plus '[37 actions]' placeholder consumes space without conveying actionable information.

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 37-action dispatcher with no output schema, no annotations, 0% parameter coverage, and a free-form nested args object, the description is far too thin. An agent cannot determine which action strings are legal or what arguments each expects, making correct invocation essentially guesswork.

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 nested 'args' object is entirely undocumented. The description implies an action vocabulary (add, move, trim, split...) but never states that these are the valid values for the required 'action' parameter or explains the shape of 'args', so it only marginally compensates for the schema 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?

The description names the resource (timeline tracks and clips) and enumerates operation types (add, move, trim, split, markers, multicam), which does distinguish it from siblings like effects, audio, or project. However it never states a clean verb+resource purpose sentence and leaves 37 actions opaque, so the agent knows the domain but not the scope of a given call.

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 guidance, no mention of prerequisites (e.g. an open project/sequence), and no routing to sibling tools for related work like audio or effects. The agent must infer everything from the tool name.

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

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 says nothing about side effects, permissions, reversibility, or output format, only naming a few operations. This is a critical gap for a tool that likely modifies project state.

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 short but poorly structured: it ends with an unhelpful meta-truncation '[25 actions]' and lacks a clear front-loaded statement of the tool's overall function. The fragment does not earn its place as a useful definition.

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 dispatcher with 25 actions, a nested 'args' object, no output schema, no annotations, and 0% schema coverage, the description is far too sparse. It provides no action enumeration, invocation guidance, or behavioral context, leaving the agent unable to call it correctly.

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 both parameters, and the description only names a handful of possible actions without explaining the required 'action' string or the nested 'args' object structure. It adds minimal value beyond the bare schema and does not compensate for the complete lack of parameter documentation.

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 lists several tracking-related operations (point/planar/mesh/feature tracking, stabilize, camera solve, lens undistort, track validation), which conveys the domain and distinguishes it from unrelated siblings like audio or color_grade. However, it never states what the tool does as a whole (e.g., 'perform tracking operations') and the truncated '[25 actions]' leaves the scope unclear.

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 tool versus siblings such as vfx3d or effects, nor any prerequisites, alternatives, or exclusions. The description is purely a capability list with zero routing 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 exist, so the description carries the full behavioral burden and discloses nothing: not whether operations are read-only or mutate the project, not whether they are reversible, not what permissions or render dependencies exist. The keyword list conveys zero behavioral context.

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

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

The description is short and scannable, with the domain keywords front-loaded. But it is a bare noun list with no verb or dispatch structure, and the bracketed '[15 actions]' is metadata noise rather than useful information.

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 complex multi-action dispatcher over a nested args object, with no annotations and no output schema, the description is nowhere near complete. An agent cannot determine the valid action values, the arg shape, or the effect of any operation from this text.

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 both parameters, and the nested 'args' object is entirely undocumented. The description neither explains that 'action' selects one of 15 operations nor hints at what 'args' must contain, so it fails to compensate for the coverage 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?

The description names a topical domain — 3D scenes, lights/materials, relight, particles, shard bursts, fracture glass — so an agent can tell it apart from siblings like color_grade, audio or tracking. However, there is no verb and no statement of what the tool actually does (create, apply, render?), and it never says it is a 15-action dispatcher. It reads as a keyword bag, not a purpose.

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, when-not-to-use, or alternative is given. Borderline cases with the effects, graphics and masks siblings are unaddressed, and the '[15 actions]' hint signals a dispatcher without ever naming the actions that would let an agent choose this tool over another.

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