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

With no annotations, the description carries the full burden. It usefully discloses the pixel-art constraint ("Integer/nearest-neighbour only — never blurred"), but omits that the timeline is replaced by default, what happens to an existing timeline, or any side effects and auth needs.

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 tightly packed sentences with the core action front-loaded and a compact example at the end. The preset list partially duplicates the schema enum, which is mild waste but still aids quick scanning.

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 10-parameter mutation tool with no annotations and no output schema, the description covers the primary path adequately but leaves half the parameters and the replace/append semantics unaddressed. An agent could call it for the common case but would be guessing on seed and sourceFrame.

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 only 40%, so the description should compensate more than it does. The example clarifies preset, frames, durationMs, and amplitude, but seed, tags, easing, and sourceFrame receive no explanation in either the description or the 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?

"Build a full animation timeline from the active frame" gives a specific verb and resource with clear scope. It does not distinguish the tool from close siblings such as sprite_tween, sprite_timing, or sprite_loop, so an agent must infer the boundary.

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

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

Usage is implied through "Presets: idle_bob, walk_cycle..." and a concrete example invocation, which suggests when the tool applies. There is no explicit when-not-to-use statement and no routing to sprite_tween or sprite_loop for alternative animation workflows.

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 supplied, so the description carries the full disclosure burden. "List" implies a non-mutating read and the scope of what is returned is spelled out by category, which is genuinely useful. However, it says nothing about the shape of the response (flat list vs. grouped sections), size, or whether anything is filtered by the current project — meaningful gaps for a catalog tool with no output schema.

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?

Two short sentences with no filler: the first front-loads the exact contents, the second gives the usage rule. Every clause earns its place and the enumerated list is the most compact way to convey scope.

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

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

With zero parameters and no output schema, the description must carry the return-content burden, and enumerating the five categories largely does that. The remaining gap is structural detail about how the catalog is organized in the response, which matters for a discovery tool but is a minor omission given how simple the call is.

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 input schema is an empty object with zero parameters, so there is no parameter semantics to add beyond the schema; the baseline of 4 applies. The description correctly avoids inventing any arguments and does not mislead the agent into expecting filters.

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 uses the specific verb "List" and enumerates the five resource categories covered: generators, animation presets, palettes, font characters, and export formats. That is far more precise than the bare title "Catalog," and the breadth signals it is the superset tool relative to narrower siblings like sprite_list_palettes. It stops short of naming those siblings explicitly, so the differentiation is implied 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?

"Use it to discover capabilities instead of reading source files" is a real when-to-use instruction that names a concrete alternative behavior (source inspection) and steers the agent toward this tool first. There is no guidance about when to prefer the narrower siblings (sprite_list_palettes, sprite_policy, sprite_quickstart) or whether this should be called before or after them, so the routing guidance is one-sided.

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 load and does a decent job: it discloses the output shape (score, letter grade, and concrete next tool calls), which is the key behavior of a critique tool. It omits whether the tool mutates the project and whether it costs generation budget, so the safety profile still has to be inferred.

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?

Two short sentences with the rubric and output format front-loaded and the usage cue last. Nothing is wasted.

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

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

For a one-optional-parameter critique tool with no output schema, the description supplies enough: what is measured, the score scale, the grade, and that next tool calls come back. The only real gap is that it does not state that the critique leaves the project unchanged.

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 100% and the single optional project parameter is already documented as "Project id. Omit to use the active project." The description adds no further semantics about that parameter, so the schema-side baseline of 3 applies.

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

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

The description gives a specific verb ("Scores") plus the exact rubric it evaluates: color economy, silhouette, outline, shading and animation. The detail of the numeric 0–100 scale, S–D grade and returned next-tool calls makes it clearly distinguishable from siblings like sprite_inspect or sprite_export, though it never names those siblings.

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

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

"Use it before exporting" gives one concrete when-to-use cue, which is genuinely helpful context. It offers no when-not guidance and does not name an alternative tool (e.g. sprite_verify_integrity or sprite_inspect) for cases where a correctness check rather than a quality critique is wanted.

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 does disclose the most important behavior: deletion is session-scoped and exported files survive. It omits whether unsaved work is lost irreversibly, whether the active project can be deleted, and what happens to dependent state (layers/frames) — all material for a destructive 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?

One sentence, front-loaded with the action and scope, with the destructive-scope caveat in parentheses. Nothing redundant remains.

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

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

For a one-parameter destructive tool with no annotations and no output schema, the definition covers scope but not confirmability, reversibility, or error conditions. It is minimally adequate but leaves the agent guessing about consequences of deleting the active or unsaved project.

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 100%, and the single 'project' param is already documented as the project id to delete. The description adds no format, id-source, or validation guidance beyond the schema, so baseline 3 applies.

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

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

States a specific verb and resource ('Remove a project') and scopes it to the 'in-memory session', which sets it apart from file-level operations. It doesn't explicitly distinguish itself from sibling lifecycle tools like sprite_save_project, sprite_load_project, or sprite_new_project, so sibling differentiation is only partial.

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

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

Usage is only implied by the parenthetical about exported files; there is no explicit 'use this when' or named alternative (e.g., to persist a project first, use sprite_save_project). The agent must infer the lifecycle context 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?

With no annotations supplied, the description carries the full burden and does disclose a meaningful side effect implicitly through the schema-backed 'clear' behavior, plus target semantics (layer, frame, project offsets, mirroring, scale). It still omits what happens to existing pixels when clear is false, what the call returns, and whether a missing layer/frame is created or an error - notable gaps for a mutation tool.

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

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

Front-loaded with the core instruction and backed by a compact inline example that removes ambiguity about grid/legend shape. Slightly dense with stacked clauses and a stray punctuation artifact ('"." / space = transparent'), but nearly every sentence adds usable 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 12-parameter tool with no output schema and no annotations, the definition covers the essential call pattern, the legend fallback, multi-frame authoring, and targeting scope. Remaining gaps (return value, layer auto-creation, mirrorY behavior) are modest relative to how much of the invocation contract is already conveyed.

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 already 83%, so most parameters are documented structurally. The description does add real value for the two most confusing inputs - the legend value grammar (hex, semantic role, palette index, 'ramp:3', 'transparent') and the grid multi-frame '---' convention - but says nothing about at, scale, mirrorX/mirrorY, durationMs, or namePrefix beyond the 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?

States a specific verb+resource ('write the sprite as text rows') and spells out the exact representation (one character per pixel, mapped through legend). It also positions itself against the sibling set as 'THE PRIMARY DRAWING TOOL for LLMs', so an agent knows to prefer it over the lower-level drawing siblings.

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

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

Gives clear operational guidance: default to text-row drawing, use '---' lines to produce multiple animation frames in one call, and omit legend to fall back to auto-mapped palette roles. What it lacks is an explicit statement of when NOT to use it (e.g. versus sprite_draw_ops for precise op sequences or sprite_generate for produced art), so the agent must infer the boundary.

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 useful traits: ops are snapped to integer pixels, "shade" adds hue-shifted light/shadow, and "outline" produces a real silhouette outline. It says nothing about whether drawing overwrites existing pixels, whether it is undoable, or what permissions/state it requires on the target project.

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 with the core concept, then the op list, then the example, then two clarifying sentences on ambiguous ops – logical ordering with little waste. The 18-item op enumeration is a single dense sentence, which is justified by the opacity of the `ops` parameter.

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

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

For a 5-param mutation tool with no annotations and no output schema, the definition explains the operation vocabulary well but omits the effect on existing artwork, frame/layer targeting semantics beyond schema hints, and any result information. Adequate to invoke the tool, incomplete for predicting consequences.

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 100% for the top-level params, so baseline is 3, but the description goes further for the opaque `ops` array (schema declares only additionalProperties: {}): it enumerates 18 op names and supplies a concrete three-op example with field names. It does not document the per-op field vocabulary (x/y/w/h/color/mode) systematically, so it stops short of 5.

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?

"Vector-ish pixel ops, all snapped to integer pixels" plus an enumerated op list states a specific verb (draw) and resource (pixel ops) clearly. It never names a sibling, so an agent must infer the boundary with sprite_draw_grid, sprite_generate, or sprite_enhance on its own.

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: nothing says when to reach for this versus sprite_draw_grid (grid drawing) or sprite_generate (generative art), both of which are plausible alternatives in the sibling list. Usage is only implied by the op enumeration.

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. It is silent on whether pixels are modified in place, whether the operation is reversible/undoable, how scope resolves (allFrames defaults true per schema, but the description never mentions it), and what happens if all effect flags are false. Only the visual transforms themselves are disclosed.

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 packs the effect list efficiently and the example is compact and demonstrates a working call. Minor cost: the effect list is dense prose that could be a terser enumeration, but little is wasted.

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

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

For a 13-parameter mutation tool with no annotations and no output schema, the description should state scope semantics (allFrames default true), defaults for the effect booleans, and whether changes are destructive. None of that is covered, leaving the agent under-informed before a state-changing call.

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 description maps to several parameters (outline, shade, despeckle, limitColors, symmetry, center) and the example supplies concrete values and ranges (limitColors:16, upper bound 64 in schema). However, with 38% coverage, seven parameters — crop, frame, layer, project, allFrames, light, harmonize — get no meaning from either schema or description, and 'light'/'harmonize' are the least self-explanatory.

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 concrete operations (despeckle, palette limiting, outline, hue-shifted shading, symmetry/centering) so an agent knows this is a batch beautification pass on sprite pixels. It is clear but never states the tool's verb/resource explicitly (e.g. 'modifies the active frame's layer') and doesn't distinguish itself from siblings like sprite_draw_ops or sprite_generate.

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 reach for this versus sprite_generate, sprite_draw_ops, or sprite_critique, nor when not to. 'One-click pro polish' implies a finishing step but the agent must infer that, and no prerequisites or preconditions are given.

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

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

With no annotations, the description does carry the important disclosure that this is a write operation producing real files on disk, plus a note about what it returns: absolute paths and an inline preview. It omits material behavior: the output root location, whether existing files are overwritten, what errors occur for invalid formats or directories, and whether the operation is destructive or idempotent.

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 key constraint, which is writing real files rather than source files, appears up front, followed by the format catalog and a compact example. The telegraphic style is dense but nearly every clause carries information; only minor wording could be tightened.

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 11-parameter mutation tool with no annotations and no output schema, the description adequately explains the format dimension and the return value. It still leaves gaps around destination root, file collision behavior, and error conditions, which an agent would need in order to call this tool safely the first time.

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

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

The schema covers 82% of parameters, so the baseline is 3. The description earns an extra point by clarifying format semantics that the enum names alone do not convey: 'png (per frame)', 'apng (lossless animated PNG)', 'svg (animated)', 'spritesheet (PNG + atlas JSON)'. The worked example also shows a valid combination of formats, scale, and atlas that illustrates how parameters interact.

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 concrete action on a concrete resource, namely writing asset files in a list of named formats, and it enumerates those formats explicitly. By stating that the tool never writes source files, it implicitly draws a boundary with sprite_save_project, which is a useful distinction, though that sibling is never named.

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 phrase 'never source files' implies that persistent project state belongs to another tool, and the format list implies when this tool is appropriate. However, there is no explicit guidance on when to choose sprite_export over sprite_save_project, sprite_gallery, or sprite_preview, and no stated preconditions such as an active or selected 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?

With no annotations at all, the description carries the full disclosure burden, and it omits everything behavioral: that 'delete' is destructive and irreversible, whether 'rename'/'tag' require an existing name, what happens when an index is out of range, and whether the active frame changes after 'select'. The single added fact — that indices are 0-based — is genuinely useful but far from sufficient for a tool containing a destructive 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?

A single compact line that front-loads the operation list and appends the one cross-cutting detail. There is no filler, though the extreme terseness is under-specification rather than true efficiency.

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 eight-parameter, eight-action mutation tool with no annotations and no output schema, this description leaves major gaps: no action-to-parameter mapping, no destructiveness warning, no statement of what is returned or how the active frame/project defaults interact. It is a menu of operation names rather than an operating manual.

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 only 50%, so the description must compensate; it partly does by clarifying that indices are 0-based, which directly affects how 'frame' and 'to' are interpreted. However, it never maps parameters to actions — 'to' is only for reorder, 'all' and 'durationMs' only for set_duration, 'name' for rename, 'tags' for tag — leaving the agent to infer which of the eight parameters are meaningful for the chosen action.

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 eight concrete operations (add, duplicate, delete, rename, select, set_duration, tag, reorder) performed on the resource named by the tool, so an agent can immediately tell this is the frame-manipulation tool and not, say, sprite_layer or sprite_timing. It stops short of a prose statement of scope (what a frame belongs to, whether operations are project-scoped), but the verb list is specific enough to be actionable.

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 (active project vs 'project' param, active frame vs 'frame' param), and no routing to alternatives among the many sibling tools such as sprite_animate or sprite_timing. The action list implies capability but never says which action to pick when, or what conditions make an operation invalid.

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. It does useful work by declaring the output is fully self-contained, offline-capable, and sandbox-preview-safe, but it never says whether a file is written to disk, where it lands, whether an existing file is overwritten, or what is returned to the caller.

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?

Two sentences, front-loaded with what gets produced, then the feature list in parentheses. Dense but every clause conveys concrete content; no filler or restatement of the tool name.

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

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

With no output schema and no annotations, the description must hold everything, and it does adequately describe the returned artifact and its runtime properties. It falls short on the write side — path resolution, overwrite behavior, and the meaning of four undocumented parameters — which matters for a tool that produces a file.

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 only 33%, and the description does not compensate: dir, scale, title, background, and the base name parameter are never explained in terms of effect on the generated HTML. The only implicit parameter signal is the base64/feature list, which hints at what the output contains rather than what each input changes.

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 ('Write a fully self-contained HTML animation player') and enumerates the artifact's contents (base64 PNGs, playback controls, onion skin, zoom, palette swatches, frame tags). That goes well beyond a tautology, though it never names the nearest siblings (sprite_export, sprite_preview) to distinguish itself.

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 or when-not guidance, and the obvious alternatives in this toolkit — sprite_preview and sprite_export — are never mentioned. 'Works offline and in a sandboxed preview' sketches a use context but does not tell an agent when to pick this over exporting or previewing by another route.

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 supplied, so the description carries the full burden. It does add real behavior beyond the schema: animated kinds (slime/ghost/coin/star/torch/tile_water/tile_lava) automatically build a full looping timeline, which is a meaningful side effect an agent must know. However, it omits what happens to existing artwork when a kind is generated, whether the operation is destructive or reversible, and what the call returns.

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

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

Front-loaded with the core value proposition, then the operational details. The long kind list is justified by the absence of an enum in the schema, but it is a single dense sentence that is harder to scan than a grouped listing (base kinds vs. tile kinds vs. animated kinds).

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 mutation tool with no annotations and no output schema, the description should cover what is returned (asset id? preview? timeline handle) and whether generation overwrites the active project's timeline or layer. It covers kinds and animation well but leaves these return/overwrite questions to inference, which is a real gap at this complexity.

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 78% (baseline 3), and the description earns above baseline by supplying the complete kind vocabulary where the schema only offers examples like 'hero' or 'tile_water' with no enum constraint. The animated-kinds subset also tells the agent which values trigger timeline generation, a semantic link not present in the schema. Remaining params (frame, layer, frames, durationMs) are left entirely to the 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 states the resource concretely: procedurally generated, seeded pixel-art 'recipes', then enumerates all 23 valid kinds so the agent knows exactly what can be produced. It implicitly distinguishes itself from drawing-based siblings by emphasizing 'one-call, hand-designed', but does not name sprite_draw_ops or sprite_animate as the alternatives.

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

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

There is one routing hint ('Call sprite_catalog for the full list'), which is more about discovery than alternative selection. The description never says when to prefer this over sprite_draw_ops, sprite_draw_grid, or sprite_quickstart, nor what prerequisites exist (active project, palette). Usage is implied rather than 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 supplied, so the description carries the full behavioral burden. It does disclose the shape of the output (ASCII grid + legend + color histogram) and implies a non-mutating read, but says nothing about cost, size limits, or what happens when the requested frame/layer does not 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?

Two short sentences with zero filler, front-loading what is returned before the usage rationale. Nothing could be removed without losing 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?

There is no output schema, so the description must convey return content, and it does so at a useful level (grid, legend, histogram). The remaining gap is minor: the undocumented maxWidth parameter and the absence of any note on resolution/truncation behavior for large frames.

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 75%, so the schema already explains frame, layer and project defaults. The description adds no parameter meaning at all, and maxWidth — the one parameter with no schema description — is left completely unexplained (no mention that it caps grid width).

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 concrete verb and return artifact: return the frame as an ASCII grid, legend and color histogram, and scopes it to a single frame. That is enough to tell it apart from image-returning siblings, but it never names the sibling (sprite_preview) that an agent would otherwise reach for.

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 a clear use context: text-only reasoning, and iterating on one frame without vision. It implies the alternative (vision-based preview) but does not name it or state when this tool should not be used, so it stops short of explicit routing.

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 supplied, the description carries the full disclosure burden. It does add two genuinely behavioral facts (opacity uses ordered dithering and introduces no new colors; layers are per-frame), but it says nothing about whether 'remove' is destructive/undoable, what lock prevents, or what any operation returns.

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

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

Two tight sentences with the operation list front-loaded and the caveats (dithering, per-frame existence) trailing. No filler or redundancy.

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 7-parameter mutation tool with no annotations and no output schema, the description covers action semantics but omits safety/irreversibility of remove, permission or lock semantics, and any expectation about the response, leaving meaningful gaps an agent must guess at.

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 71%, so the schema documents frame, layer, project and allFrames. The description adds real meaning for the opacity action and the per-frame nature of layers, but leaves newName (undocumented in both schema and description) and the interaction of allFrames with show/hide/lock unaddressed.

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 concrete resource (layers) and enumerates the exact operations (add/remove/rename/show/hide/lock/opacity), so an agent knows precisely what domain this tool covers. It stops short of naming a sibling it is not (e.g., sprite_frame for frame-level work), leaving that inference implicit.

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

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

The verb list implies when to reach for this tool, and 'Layers exist per frame' hints at scope boundaries, but there is no explicit when-to-use/when-not guidance or reference to alternatives such as sprite_frame or sprite_draw_ops.

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 still discloses that the data is 'built-in curated' — i.e. a fixed, read-only catalog — and what fields come back (roles, hex colors). It does not explicitly state that the call has no side effects or whether the list can change, which keeps it below 5.

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?

Two short sentences: the first defines the tool and its output, the second gives actionable downstream guidance. Nothing is redundant or padded.

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

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

For a zero-parameter, annotation-free enumeration tool with no output schema, the description supplies everything needed: it says what is listed, what each entry carries, and how to use the result. No gaps remain that would block a correct call.

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

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

The tool takes zero parameters, so the baseline is 4. The description correctly adds nothing about inputs because there are none, and the only naming it discusses (`name`) refers to a field in the returned data, not an argument.

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 (list), a specific resource (built-in curated pixel-art palettes), and what each entry contains (roles and hex colors). That distinguishes it clearly from sprite_palette, which applies a palette rather than enumerating 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?

The second sentence tells the agent what to do with the returned `name` (pass it to sprite_new_project or sprite_palette), which places the tool in the workflow. It stops short of an explicit when-to-use/when-not statement or a named alternative for enumeration, so it does not reach 5.

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 supplied, so the description carries the full behavioral burden. It does disclose one genuinely useful trait - projects are shared across stdio and HTTP connections, i.e. session-scoped state - but says nothing about the return shape (names vs ids), ordering, or behavior when no projects 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?

A single front-loaded sentence with no filler; the parenthetical scope clarification is the only elaboration and it earns its place.

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 parameterless read tool with no output schema, the definition covers the essential question of what set of projects is listed and that it is session-wide. Only the returned fields are left unstated, which is a minor gap.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey and the baseline of 4 applies. The description correctly does not waste words on inputs.

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: 'List all projects currently held in the server session.' An agent can distinguish this discovery call from single-project siblings like sprite_project_info or sprite_select_project, though those are never named 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?

Usage is only implied: an agent can infer this is the discovery step before select/load/delete, but the description never says when to call it instead of sprite_project_info, sprite_catalog, or sprite_gallery, and gives no preconditions.

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. 'Reading is safe; writing is still guarded' adds some safety context, but 'guarded' is undefined — an agent cannot tell whether loading overwrites an existing project, how id collisions are handled, or what 'activate' mutates. For a load tool that clearly writes state, this is a meaningful 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?

Two short sentences, front-loaded with the core action and the file-format constraint. Nothing is wasted, though the closing safety clause is terse to the point of ambiguity rather than genuinely informative.

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 annotations and no output schema, so the description should say what the call returns (project id? info?) and whether it replaces or adds state. It covers the input path convention but leaves the effect on existing project state and the 'activate' behavior unexplained, which is thin for a 3-parameter state-loading 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?

Schema coverage is 67%, and the description adds nothing beyond it — it never mentions the optional 'id' parameter or the undocumented 'activate' boolean, whose default and effect (does it make the project current?) are unknown. Only the required 'path' has any semantic clarity, and that comes from the schema text itself.

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

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

States a specific verb and resource ('Load a .spriteproj.json') and ties it to its counterpart sprite_save_project, so the round-trip is obvious. It does not, however, distinguish itself from sibling state-changing tools like sprite_new_project or sprite_select_project, which an agent could easily confuse it with.

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

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

The path-resolution rule (relative to output root or absolute) is real usage guidance, but there is no statement of when to prefer this over sprite_new_project or sprite_select_project, nor any prerequisite such as whether the target project must not already exist. Usage must be inferred from the name and format constraint.

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 does not meet it: it never says whether frames are mutated in place, whether the operation is reversible, whether it applies to the active project only, or how 'deduplicate' interacts with existing timing. The parentheticals explain what each mode means semantically, but say nothing about side effects or persistence.

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 compact sentence plus a usage example, with the mode definitions front-loaded and no filler. It is efficient, though the terseness is partly the cause of the missing context rather than pure economy.

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

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

For a mutating tool with zero annotation coverage, no output schema, and a partially documented schema, the description should establish what is being modified, whether the change is destructive, and how the modes differ in effect on timing. It only covers the mode vocabulary, leaving the agent unable to predict the result of a call.

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 33%, but the description does the important work on the enum: each mode value gets a plain-language gloss that the bare enum list lacks. 'times' is only obliquely covered ('freeze each frame N times') with no mention of the 1–20 bound, and 'project' relies entirely on its schema 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 four modes and describes each with a verb-phrase gloss ('pingpong (seamless back-and-forth)', 'hold (freeze each frame N times)'), which implies the tool reshapes the frame sequence of a loop. However, it never states at a high level what the tool operates on or produces (e.g. 'modifies the frame order of the current sprite's animation loop'), so the core purpose must be inferred from the mode names.

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 is given and no siblings are referenced, despite obvious neighbors like sprite_timing, sprite_animate, and sprite_frame that also affect playback. An agent has no signaled criteria for choosing this tool over them, nor any stated prerequisite that a loop/animation must already exist.

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 supplied, so the description carries the full behavioral burden. It discloses that the project is palette-indexed (an important constraint) but says nothing about what happens on id/name collision, whether the new project becomes the active/selected one, whether anything is written to disk, or what a failed creation looks like — all critical for a mutation tool.

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

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

Three short sentences, purpose front-loaded, then the ordering rule, then actionable sizing guidance. Nothing is redundant with the title and no sentence is filler.

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

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

For a 9-parameter creation tool with no annotations and no output schema, the description covers intent and sizing but leaves the post-call state undefined (created project id? auto-selected? error behavior). It is adequate to call the tool, but not to predict its outcome.

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 100%, so the baseline is 3; the description earns above that by giving concrete size heuristics (16x16 icons, 32x32 characters, 64x64 bosses) that the schema does not encode. It also groups the parameters conceptually (canvas size, palette, frames, layers), though it does not touch id, tags, or durationMs.

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

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

States a specific verb and resource ('Create an indexed pixel-art project') and enumerates the configuration surface: canvas size, palette, frames, layers. 'Always call this first' plus the 'new project' framing cleanly separates it from creation-adjacent siblings like sprite_load_project and sprite_save_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?

'Always call this first' is an explicit ordering directive that tells the agent this is the workflow entry point, and the classic-size examples guide parameter choice. It stops short of naming when not to use it (e.g. when a project is already selected) or pointing at sprite_quickstart as a lighter alternative.

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

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

No annotations are provided, so the description carries the full burden: it does not say whether switching a palette is persistent, whether it rewrites existing sprite colors, whether it requires a selected project, or what the response contains. 'Switch' and 'install' imply project mutation but no consequences or side effects are disclosed.

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?

Two compact sentences with no wasted words, and the read mode leads. It loses a point only because the trailing 'also lists...' clause is tacked on and competes with the main purpose rather than being framed as a mode.

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 has four parameters, multiple implicit modes, no annotations and no output schema, so the description should explain mode selection and mutation effects — it does neither. For a set/install-capable tool with zero structured behavioral hints, this is significantly under-specified.

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 75% and already documents `name`, `colors` (including the transparency-at-index-0 rule) and `project`. The description adds essentially no parameter meaning beyond saying 'combine with name to install a custom palette,' and the undocumented `description` parameter is ignored entirely 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 packs three distinct operations (inspect, set built-in, install custom) plus a fourth (list semantic color roles) into one sentence, so the verb/resource is stated but the tool's primary purpose is muddled. It never clarifies how it differs from the sibling sprite_list_palettes, which appears to overlap with the 'lists all semantic color roles' claim.

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 use this versus sprite_list_palettes, or which parameter combination triggers which of the four described modes. An agent must infer that passing `name` switches palettes and `colors`(+`name`) installs, without any explicit when-to-use or when-not-to-use statement.

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. It discloses the two categories of content returned (binding policy rules and source-integrity status), but says nothing about output format, cost, or whether the integrity report is a live check versus a cached status.

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, zero filler, with the actionable directive front-loaded ahead of the descriptive clauses. Every sentence contributes either scope, output content, or ordering 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 zero-parameter, no-annotation, no-output-schema informational tool, the description covers what the agent needs: what comes back and that it should be consulted first. Only the precise return shape and the distinction from sprite_verify_integrity are left implicit, which is a minor gap.

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

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

The schema takes zero parameters at 100% coverage, so there is nothing for the description to disambiguate. The baseline for a parameterless tool applies, and the description correctly implies no inputs are needed.

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 uses a specific verb and resource ('Returns the binding policy') and adds a secondary output ('also reports source-integrity status'), which lets an agent distinguish this from drawing-oriented siblings. It does not differentiate itself from sprite_verify_integrity, which appears to cover overlapping integrity-status ground.

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?

Provides an explicit temporal directive — 'Read this before doing anything else' — which tells the agent exactly when to call it relative to every other tool. It gives no exclusions or alternatives, and does not clarify its relationship to sprite_verify_integrity for the integrity portion.

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. It does valuable work by revealing the return shape — an inline image content block plus a text summary — which is otherwise undocumented since there is no output schema. However, it never states that the operation is read-only/non-mutating, says nothing about image size or token cost for large contact sheets, and does not describe failure modes for an invalid frame or project.

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, zero filler, and the most important fact (inline PNG the agent can see) is front-loaded. The 'all' hint and return-value note follow in descending priority order.

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 six-parameter, all-optional preview tool with no annotations and no output schema, the description covers the essential contract: what is returned and why it matters to an agent. The remaining gaps — read-only status and payload size implications of a full contact sheet — are real but secondary.

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 83%, so the schema already explains ascii, frame, scale, project, and background in adequate detail. The description's only added parameter meaning — 'all' producing a contact sheet — largely duplicates the frame property's own schema text. Baseline 3 applies when the schema does the heavy lifting.

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 opens with a specific verb and resource ('Render the sprite as an INLINE PNG image content block') and immediately differentiates this tool from siblings like sprite_export or sprite_gallery by stressing that the image is returned inline so the agent 'can actually SEE the art'. An agent can tell this is the visual-inspection path rather than a file-writing or human-gallery path without opening any schema.

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 only usage direction is parameter-level: "Use 'all' to get a contact sheet of the whole animation." There is no explicit statement of when to call this instead of sprite_export, sprite_gallery, or sprite_inspect, and no when-not guidance. Usage is implied by the 'SEE the art' framing but never operationalized.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read but never states that it is side-effect free, nor whether the response can be large or requires a loaded project; the only real disclosure is the list of returned facets, which is closer to output description than 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?

A single compact sentence with the scope front-loaded and no filler. The colon-separated field list is efficient, though it substitutes enumeration for an actual explanation of what the tool is.

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

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

With no output schema, the description must describe what comes back, and it does list the summary facets. It is still thin for a whole-project read: no read-only assurance, no indication of default/active-project behavior, and no differentiation from the many sibling inspection tools.

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?

There is a single optional parameter at 100% schema description coverage, and the schema already explains the project id and the active-project fallback. The description adds no further meaning about the parameter, so the baseline of 3 applies.

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

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

The verb 'Inspect' plus the enumerated fields (size, palette, roles, frames, durations, layers, tags) convey that this returns a full project summary. However, 'inspect' collides directly with the sibling tool sprite_inspect, and nothing in the description distinguishes the two or separates this from sprite_list_projects/sprite_preview.

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 rather than sprite_inspect, sprite_preview, or sprite_list_projects. The only usage-like guidance ('Omit to use the active project') lives in the schema, not the description, so the agent gets no routing context.

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 supplied, so the description carries the burden, but the tool is a zero-parameter read of static content with little risk surface. It does usefully disclose the return contents and that 'no source reading needed', which tells the agent the response is self-sufficient. It doesn't state whether the content is versioned or how large the response is.

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, front-loaded with the call-ordering imperative, then the payload description. Every clause earns its place with no filler.

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

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

There's no output schema, and the description compensates by enumerating the four things returned. For a no-param documentation tool this is nearly sufficient; only the shape/format of the returned workflow is left unspecified.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter semantics to compensate for. Schema coverage is 100% and empty, so nothing is missing.

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

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

The description uses a specific verb ('Returns') and enumerates the concrete payload: the Arena.ai Agent workflow, tool order, golden rules of pixel art, and a ready-to-use example. It's clear what the tool produces, though the 'resource' is a documentation bundle rather than a data object, so it reads slightly abstractly.

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 opening imperative 'Call this FIRST' gives unambiguous timing guidance with no room for inference, which is exactly the routing signal an agent needs amid 26 sprite_* siblings. It stops short of naming exclusions or alternatives (e.g., when to skip straight to sprite_policy), so it earns a 4 rather than a 5.

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. It discloses the scope of what is persisted and where the file lands, which is valuable, but says nothing about overwrite behavior, whether the tool returns the written path, or what happens if the project id is invalid.

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

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

Two sentences, no filler, with the artifact and its contents front-loaded and the follow-up action placed second. Every clause carries information an agent 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?

There is no output schema and no annotations, and two of three parameters are undocumented, so the description would need to say more about the save target and return value to be fully self-sufficient. It covers the core contract adequately for a simple save operation but leaves overwrite and result semantics open.

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 only 33% and the only documented parameter is 'project'. The description never explains 'dir' or 'name' – it only implies the file lands 'inside the output root', leaving an agent to guess whether dir is relative, absolute, or overrides the root, and how name relates to the fixed .spriteproj.json suffix.

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 ('Serialize'), a specific resource ('the full project'), an explicit enumeration of what is captured (palette, layers, all frames, durations), and the exact artifact written (.spriteproj.json in the output root). This is precise enough to distinguish it from sibling tools such as sprite_export and sprite_load_project without opening any schema.

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 clearly signals the lifecycle pairing ('Load it later with sprite_load_project'), which tells an agent when this tool belongs in a workflow. It stops short of explicitly excluding alternatives such as sprite_export or stating what to do when a save target already exists, so it is strong but not exhaustive.

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 burden, and it does disclose the key state change — that a project becomes active and that subsequent calls may then omit `project`. It does not state whether the selection persists across sessions, what happens if the id is invalid or unknown, or whether an existing active selection is silently replaced.

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 followed immediately by the payoff for the caller. No redundant restatement of the name or title, and nothing that could be cut.

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

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

For a simple one-parameter state-selection tool with no output schema and no nested objects, the description covers purpose and mechanism adequately. The only real gap is failure behavior for an invalid project id, which is minor at this complexity.

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 100% and the single parameter is documented as 'Project id to activate,' which is sufficient for correct invocation. The description adds no further meaning (id format, lookup behavior, error on unknown id) beyond the schema, so the baseline 3 applies.

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

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

The description gives a specific verb+resource ('Make a project the active one') plus the downstream consequence, so the effect is unambiguous. It does not explicitly contrast with near-siblings like sprite_load_project or sprite_new_project, so an agent must infer the boundary from names alone.

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

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

Usage is implied rather than stated: the clause 'so later calls can omit the `project` argument' tells the agent why it would call this. There is no explicit when-not guidance or named alternative (e.g. loading vs. creating vs. selecting a project).

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not explain mutation side effects, whether existing timing is overwritten, precedence when multiple timing parameters are supplied, or what the tool returns. The 10–12 fps recommendation adds some useful context but leaves critical behavior undisclosed.

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 front-loaded, compact, and every part contributes: the three modes define scope, the pixel-art recommendation adds context, and the example clarifies usage. There is no filler.

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

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

For a tool with five parameters, a nested object, no annotations, and no output schema, the description is insufficiently complete. It omits parameter precedence, units, per-frame key semantics, active-project behavior, and the effect on existing frame timing.

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 only 20%, so the description needs to compensate. It mentions fps, duration, and per-frame durations, but does not clarify the difference between the `perFrame` object and the `durations` array, does not state units for `durationMs`, and does not explain how `project` interacts with the timing parameters.

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: setting frame timing. It also names three supported modes (constant fps, constant duration, per-frame durations) and gives an example. It does not distinguish this tool from sibling animation-related tools such as sprite_animate, so it falls short of a 5.

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

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

The description lists the available timing modes but gives no guidance on when to choose fps versus durationMs versus perFrame/durations. It also does not mention alternatives or when not to use this tool.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It discloses the rendering technique and the 'no alpha blur' quality bar, but says nothing about the fact that this mutates the timeline/project, what happens to existing frames, whether the operation is reversible, or what is returned. The schema's insert=false 'replace timeline' semantics is the only signal of destructive behavior and it lives in the schema, not the description.

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?

Two tight, front-loaded sentences with no filler; the technique and constraint come first. The example sentence is marginally redundant with the schema but cheap and concrete.

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?

Scoring note: for an 8-parameter generative tool with no annotations and no output schema, the definition is thin. It omits what the operation does to the timeline, how seed/pattern/durationMs affect output, and any preconditions, leaving an agent to infer behavior from the schema alone.

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 63%; seed, pattern, and durationMs have no descriptions in either schema or prose, and the description does not explain them. The example only restates from/to/steps, which the schema already documents, so it adds almost no semantic value beyond the input 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?

States a specific verb and resource (create intermediate frames between two keyframes) plus the distinctive technique (ordered-dither cross dissolve, no alpha blur). It does not explicitly differentiate from ambiguous siblings like sprite_animate, sprite_timing, or sprite_frame, which could also plausibly produce inbetweens.

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 prerequisites (e.g. keyframes must exist, palette/project state), and no mention of when to prefer a sibling such as sprite_timing. The trailing 'Example: {from:0,to:2,steps:3}' illustrates parameter form but is not usage 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?

With no annotations, the description carries the load and does well: it discloses the exact file it reads, implies a read-only comparison, names the output flag clean, and prescribes the remedy on failure. Gaps remain around behavior when manifest.json is missing or when files are untracked, which an agent would want to know before interpreting clean=false.

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: the mechanism first, the purpose second, the failure action last. Every sentence earns its place and the safety-critical instruction is not buried.

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

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

For a zero-parameter, no-annotation tool with no output schema, the description covers mechanism, intent, and the critical failure path. It stops short of describing the rest of the response shape (which files mismatched, counts), which the agent must discover at call time since no output schema exists.

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

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

Zero parameters, so there is no parameter semantics to explain; baseline 4 applies. The description correctly implies full-repo scope with no filtering options, which is the only semantically relevant fact for a no-arg tool.

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+method: SHA-256 verification of tracked source/config files against integrity/manifest.json. That is unmistakably distinct from every sibling (palette, draw, animate, project tools), so an agent can select it without opening a schema.

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?

"Use it to prove no agent edited the code" gives a concrete condition for calling it, and the failure branch is fully specified (stop and ask a human to restore on clean=false). What is missing is the complementary trigger — when in a workflow to run it (before export, after generation) — and any statement about what to do when the manifest is absent.

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