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 says the tool shades an area, but does not disclose that it mutates an existing plot, what prerequisites exist (e.g., an existing plotted function), or any permission/reversibility considerations.

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 clearly leads with the operation and its key bounds.

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 8-parameter mutation tool with no annotations and no schema parameter descriptions, the definition is too thin. It does not explain how plot_id links the area to an existing plot or what function_index selects, leaving an agent with insufficient context to invoke it 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 description coverage is 0% across 8 parameters, and the description only explains x_min and x_max. It leaves the required plot_id, plus function_index, color, opacity, scene_id, and project_id 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 states a specific action: shading the area under a plotted function between x_min and x_max, explicitly identifying it as the integral. This distinguishes it from generic plotting tools like add_plot or add_equation, though it does not name close siblings such as add_riemann or add_step.

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 guidance on when to use add_area versus alternatives; the only usage cue is the implied integral visualization. It does not say when to choose this over add_riemann, add_step, or other plot annotations.

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 this mutates a scene, what happens with existing scene state, whether an open scene/project is required, how positioning or scaling defaults behave, or any side effects. The LaTeX syntax example is useful but 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?

The description is a single front-loaded sentence with no wasted text, and the example is compact. However, its extreme brevity leaves the tool under-specified for a 7-parameter mutation operation.

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?

Given the complexity of 7 parameters, no annotations, and an output schema present, the description is far too thin. It omits scene/project context, positioning semantics, and mutation behavior, providing only the required tex example.

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 7 parameters. The description only illustrates the required tex parameter and says nothing about x, y, color, scale, scene_id, or project_id, leaving most parameters 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 states a specific verb and resource: 'Add a LaTeX equation', and includes an example of the required tex parameter. It is clearly distinguishable from siblings like add_text and add_plot by resource type, though it does not explicitly say when to prefer this over add_text.

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 or when not to use this tool, no mention of alternatives among sibling add_* tools, and no prerequisites such as needing an open scene or project. The only usage signal is the required tex parameter example.

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 must carry the full behavioral burden. It usefully discloses two behaviors beyond the schema: the spline-smoothing artifact risk and the default-parabola fallback when functions is omitted. However, nothing is said about what happens with scene_id/project_id (which project or scene gets the axes, whether a new scene is created), idempotency, or any side effects of this mutation.

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 tight sentences, front-loaded with the core action and followed by the highest-risk gotcha. The inline dict example is dense but earns its space. Slightly under-explained rather than over-long.

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 nine-parameter mutation tool with zero annotation coverage and no schema descriptions, the description should orient the agent on placement (scene_id/project_id) and bounds (x_range/y_range). It covers functions' internal semantics well and return values are handled by the output schema, but the majority of the call surface remains 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% across 9 parameters. The description thoroughly explains only `functions` (shape, keys, defaults, smoothing flag), leaving x, y, width, height, x_range, y_range, scene_id, and project_id completely undocumented in both schema and prose. Partial compensation for one out of nine parameters is not enough.

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 + resource ('Add axes with functions') and immediately clarifies what a 'function' object looks like. It does not explicitly distinguish itself from siblings like add_equation, add_area, or add_step, so an agent must infer that this tool creates a coordinate plane rather than a single curve on an existing one.

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?

Gives concrete when-to guidance at the parameter level: smooth=false plus small dx for discontinuous/piecewise functions, functions=[] for bare axes, omit for a default parabola. It lacks any routing guidance against the sibling add_* tools, so the when-to-use-this-vs-alternative dimension is only half covered.

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 must carry the full behavioral burden. It says what is drawn and how dx affects fineness, but it omits whether the plot or scene is mutated, what happens to existing objects, required plot targeting, and any side effects or response 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 single sentence is front-loaded and has no wasted words. The parenthetical is dense, and the missing action verb keeps it from being fully self-contained, but it remains appropriately concise.

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 8-parameter drawing tool with no annotations and no schema descriptions, the description is too thin. It does not establish required plot_id targeting, optional scene/project scoping, function selection, or x-range/color effects; the output schema covers returns but input guidance remains incomplete.

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% across 8 parameters. The description explains only dx ("smaller dx = finer") and leaves plot_id, x_min, x_max, color, function_index, scene_id, and project_id undocumented.

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 identifies the resource as Riemann rectangles under a plotted function and explains that dx controls fineness, so the agent can tell this draws an approximation visualization. It stops short of an explicit action verb and does not distinguish this from siblings such as add_area or add_equation.

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?

It provides an implied use case (coarse-to-fine convergence) and explains the effect of dx, but it does not say when to choose this over add_area, add_equation, or other drawing tools, nor does it list prerequisites or exclusions.

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 disclosure burden, yet it only says 'append.' It does not state whether the scene is appended at the end, what happens when project_id is omitted/null, whether the operation is reversible, or what side effects occur. 'Append' weakly implies ordering, which is the only behavioral signal.

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 front-loaded and waste-free, but for a mutation tool with zero annotations it is under-specified rather than genuinely concise. It is a minimum-viable sentence, not an efficient complete one.

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?

An output schema exists, so return values need not be described. However, with no annotations, two undocumented parameters at 0% coverage, and no statement of mutation semantics, the description is not complete enough for an agent to call this tool 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 description coverage is 0%, and the description does not mention either parameter. It never explains that title labels the scene or that project_id selects the target project (and what the default null means). The word 'project' hints at project_id, but title is entirely undocumented.

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 (append) and resource (scene) scoped to the project, so the agent can tell it apart from siblings like add_plot or add_area. It stops short of differentiating against the other add_* tools or naming when a scene is the right target.

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 such as an open project, and no routing to alternatives among the many add_* siblings. The agent must infer usage entirely from the 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?

There are no annotations, so the description carries the full behavioral burden for a mutation-like creation tool. It says what is added but not how coordinates are interpreted, whether width/height override size, what color formats are accepted, or what targeting constraints apply to scene_id/project_id.

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 filler, and the list of shape values is useful. It is efficient, though its brevity is also the source of the definition's larger completeness 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 9-parameter creation tool with no annotations, the description is too thin. The output schema can cover return values, but the description still needs to explain targeting, coordinate conventions, and parameter interactions well enough for an agent to call it safely.

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 compensates only for the shape parameter by listing circle, square, rectangle, triangle, arrow, dot, and line. It says nothing about x, y, size, width, height, color, scene_id, or project_id, leaving most of the 9 parameters undocumented beyond their bare names.

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 ('Add') and resource ('primitive geometry') and lists valid shape values, making the tool's basic purpose clear. It does not explicitly differentiate this tool from nearby siblings such as add_area or add_plot, but the primitive-geometry scope is still distinct.

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 lists usable shape types but gives no guidance on when to choose add_shape over siblings like add_area, add_plot, or add_text. It also does not mention scene_id/project_id targeting or whether an open project/scene 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. It implies a mutation ('Append') and describes two kind-specific behaviors, but omits persistence, ordering, project/scene context, side effects, and what happens to existing steps. That is a significant gap for a 10-parameter mutation tool.

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

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

The definition is two short sentences with no filler. The core action is front-loaded, followed by the kind enumeration and the most important kind-specific parameter routing.

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?

The tool is a 10-parameter mutation with no annotations and 0% schema description coverage. The description covers only a fraction of the parameters and omits core context such as scene/project binding, duration semantics, and targets. An output schema exists, so return values need not be described, but the input-side gaps remain substantial.

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% across 10 parameters, so the description must compensate. It usefully explains the kind values, `to` for transform, and zoom/focus for camera_move, but note, targets, duration, scene_id, project_id, and focus_x/focus_y remain unexplained.

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 resource: 'Append a timed beat.' The kind enumeration clarifies the domain (write, transform, highlight, fade, camera_move, wait). It does not distinguish this tool from siblings like add_scene or add_text, but the purpose itself is clear.

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?

It gives conditional guidance for two kinds ('For transform, set to...'; 'For camera_move, set zoom/focus'), but never says when to use add_step versus alternatives like add_scene, add_shape, or add_text. There are 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, so the description must carry the behavioral burden. It implies a mutation via 'Add' but does not explain persistence, required scene/project context, authorization, or how the text is rendered into the scene.

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 one-line fragment is concise but severely under-specified rather than efficiently informative. For an eight-parameter creation tool, this brevity leaves essential context missing.

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?

Given eight parameters, no annotations, and zero schema description coverage, the description is not complete enough to call the tool correctly. The output schema helps with return values, but the description does almost nothing to explain inputs, context, or behavior.

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 has eight parameters with 0% schema description coverage, and the description explains none of them. It does not clarify x/y positioning, color format, scale, font_size, scene_id, or project_id, leaving the agent unable to infer parameter meanings from the definition alone.

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 a specific verb ('Add') and names content types ('title/label/callout'), so the agent knows this creates text overlays rather than shapes or equations. However, it does not clarify the relationship to scene_id/project_id or distinguish it precisely from sibling add_* tools.

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 add_text versus add_shape, add_equation, add_plot, or other sibling tools. The mention of title/label/callout implies a use case, but no alternatives or exclusions 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?

No annotations are provided, so the description carries the full behavioral burden. 'Release the project session' hints at cleanup, but it does not say whether project data is preserved, whether the session must be active, whether permissions are required, or what side effects occur.

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, but it is under-specified rather than appropriately concise for a session-closing operation with no annotations.

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?

An output schema exists, so return values need not be explained. However, for a mutation-like tool with no annotations and an undocumented optional parameter, the description omits critical context about side effects, prerequisites, and parameter meaning.

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 project_id has 0% schema description coverage, and the description does not mention it at all. An agent cannot tell from the description whether project_id is required, what format it takes, or what happens when it is 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?

The description gives a verb and resource ('Release the project session'), but 'release' and 'session' are vague for a tool named close_project. It does not clearly distinguish closing a project from merely ending a session, nor does it reference the opposite sibling open_project.

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, when not to use it, prerequisites such as whether the project must already be open, or alternatives among siblings like inspect_project or open_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, so the description carries the full burden. It does disclose one real behavioral trait: the operation can be blocked by unresolved error obligations, and it exports an existing render rather than re-rendering. It says nothing about permissions, output location, size limits, or whether the export is saved server-side or 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 sentence, front-loaded with the action and result, with the blocking caveat confined to a parenthetical. Nothing is wasted, though the terseness comes at the cost of the missing parameter and output 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?

An output schema exists so return values need not be explained, but the description fails to resolve the core ambiguity of two optional, zero-coverage identifier parameters and leaves 'open error obligations' undefined. For a tool whose inputs are mutually ambiguous, this is not enough to invoke it 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 (scene_id, project_id) are optional and undocumented. The description never explains the relationship between the two identifiers, which one is needed, or whether both are required together, so the ambiguity an agent most needs resolved is left open.

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: exports the latest render of a scene as a GIF. The word 'latest render' implicitly distinguishes it from render_scene/render_frame, which produce renders rather than export them, 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?

'Blocked by open error obligations' hints at a precondition, and 'latest render' implies a render must exist first, which is useful contextual guidance. However, there is no explicit statement of when to call this instead of render_scene/render_frame, and no mention of what to do if no render exists.

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 discloses the diagnostic content (provider presence and degradation impact), but does not state that the operation is read-only, whether it has side effects, or whether it requires any setup. For a zero-parameter inspection tool this is partially adequate, but it leaves safety and execution behavior unstated.

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 compact sentence with no wasted words. It is front-loaded with the provider list and then the degradation context. It is slightly fragment-like rather than a complete sentence, but the information density is high.

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?

Given zero parameters and an output schema, the description need not explain return values. It communicates the core diagnostic purpose and the practical consequence of missing providers. Slightly more context about read-only behavior would make it fully complete for an unannotated 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 no parameters, and the schema description coverage is 100%. With zero parameters there is no parameter semantics to explain, so the baseline is 4; no description content is needed here.

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 (environment providers: Manim, LaTeX, ffmpeg, vision) and the outcome (what degrades without each). The verb is implicit rather than stated, and it does not explicitly distinguish itself from siblings like inspect_project or inspect_render, but an agent can infer it is a capability/dependency diagnostic.

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, no prerequisites, and no alternatives named. The phrase 'what degrades without each' implies it is useful for diagnosing missing dependencies, but the agent must infer this from the wording rather than being told when to call it instead of other inspect tools.

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 at all, the description carries the full behavioral burden, and it discloses almost nothing. 'Inspect' weakly implies a read-only operation, but there is no statement about side effects, permissions, whether project_id=null resolves to the current project, or how large the returned state can be.

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 very short with zero filler, but it is a noun fragment rather than a front-loaded sentence, so its brevity comes at the cost of clarity. There is no wasted text, yet the single clause does little structural work.

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?

An output schema exists, so return-value detail is not required. Still, for a tool with no annotations whatsoever and an undocumented parameter, the definition is too thin — usage context, read-only confirmation, and project_id resolution behavior are all missing.

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 project_id parameter, so the description must compensate and largely does not. The word 'current' faintly hints that omitting project_id targets the active project, but the null/default semantics and accepted ID format are never 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 fragment names the resource (project state) and enumerates what it surfaces (scenes, steps, open obligations), which hints at a read operation. However, there is no verb and no explicit differentiation from siblings like inspect_environment or inspect_render beyond the noun 'project'. The purpose is inferable rather than stated.

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, and no reference to any alternative tool. An agent cannot tell from this text whether to call inspect_project before open_project, or how it differs from inspect_environment/inspect_render.

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 some useful context: it uses the latest render if present and otherwise runs graph-only lanes, and it returns verdicts and obligations. However, it does not state whether the operation is read-only, what side effects it may have, or what permissions are 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?

The description is two sentences, front-loaded with the primary action and followed by the key conditional behavior. Every sentence contributes relevant information without unnecessary 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?

An output schema exists, so return-value explanation is less critical, and the description covers the core lane behavior. But for a tool with no annotations and two undocumented optional parameters, the description leaves important gaps around parameter usage, permissions, and side effects.

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?

Both parameters have 0% schema description coverage, so the description must compensate. It mentions a scene but never explains the roles of scene_id or project_id, their optionality, or what happens when either is 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?

The description states a specific verb and resource: it runs geometric verification lanes on a scene and returns a verdict plus obligations. It is clearly distinct from project/environment siblings, though it does not explicitly name alternatives. The domain jargon is meaningful but slightly opaque.

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 explains what the tool does internally but gives no guidance on when to use it versus inspect_project, inspect_environment, or render_scene. It also provides no exclusions or prerequisites for choosing this 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 burden and discloses almost nothing: it doesn't say a session is created/held, whether state persists until close_project, whether calling twice is an error, or how fps affects output. Only the two enumerations add real information.

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?

Front-loaded and free of filler; the key action comes first followed by the two enumerations. The telegraphic 'quality: draft|low|medium|high' style is terse but parseable, and nothing superfluous is included.

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?

An output schema exists so return values needn't be described, but for a stateful session-opening tool with zero annotations and 0% schema coverage, the description omits the lifecycle contract, the meaning of defaults, and the fps parameter 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 coverage is 0%, so the description is the only source of parameter meaning, and it supplies value domains for quality and theme that the schema lacks (schema declares them as free-form strings with no enums). However, 'fps' is never mentioned and no defaults or effects of quality/theme are explained.

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?

'Start a project session' gives a clear verb and resource, and 'open' vs the sibling 'close_project'/'inspect_project' is self-evident. It never explicitly distinguishes itself from those siblings, but the intent 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 guidance on when to call it, whether it must precede add_scene/add_equation, whether an existing session must be closed first, or what happens if one is already open. The agent has to infer the whole session lifecycle from sibling names.

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 must carry the behavioral burden. It only says the tool is fast and produces a single still of the last frame; it does not disclose whether rendering writes files, creates caches, requires permissions, or has other 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?

The description is a single front-loaded sentence with no padding. It is efficient, though its extreme brevity leaves important details unstated rather than wasting words.

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?

The output schema means return values need not be explained, but the definition still lacks usage guidance and parameter semantics. With no annotations and 0% schema description coverage, an agent cannot determine how scene_id and project_id should be supplied or when this tool is preferred over render_scene.

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 has two parameters with 0% schema description coverage, and the description does not explain scene_id or project_id. Mentioning 'a scene' only echoes the name scene_id and leaves project_id and the relationship between the two identifiers entirely undocumented.

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 a clear verb and resource: render a single still frame. 'Fast single-still preview' and '(last frame)' make it more specific than a generic render call and hint at a difference from render_scene, though it does not explicitly name that sibling.

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 words 'preview' and 'fast' imply using this for quick inspection rather than final output, but the description does not say when to use it instead of render_scene. It gives only implied usage guidance with no explicit alternatives or exclusions.

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 non-obvious compound behavior: this is a heavy render that emits both a video and sampled frames and then triggers verification lanes. However, it says nothing about prerequisites (open project, existing scene), runtime/cost, whether existing artifacts are overwritten, or failure modes of the verification step.

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 the action first and outputs after; no wasted clauses. "Verification lanes" is unexplained jargon, which is the only real structural weakness.

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?

The existence of an output schema relieves the need to describe return values, and the compound render-then-verify flow is captured. But for an expensive, side-effecting, zero-annotation tool with two undocumented optional parameters, the description leaves too much unsaid about prerequisites and parameter meaning.

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 (scene_id, project_id) are optional with null defaults. The description never explains what each identifies, what happens when either is null, or how they interact — exactly the ambiguity that most needs description support.

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 ("Render one scene") plus two concrete outputs (video, sampled frames) and a follow-on step (verification lanes). It clearly implies it is not the single-frame sibling, though it never names render_frame, so differentiation is inferred rather than stated.

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, or alternative routing is given. The phrase "one scene" hints that project-wide rendering is out of scope, but an agent gets no guidance on choosing this over render_frame, export_gif, or inspect_render.

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