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

With no annotations, the description carries the full burden and discloses the key side effect: a copy is created in the working folder and the original is never touched. It also clarifies idempotent behavior for paths already in the working folder, though it omits error handling or response details.

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 zero waste; the copy-first guarantee and the already-local shortcut are both front-loaded. Every clause 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 one-parameter mutation-like tool with no annotations and no output schema, the description covers the critical behavioral context: format support, copy creation, original safety, and the local-path shortcut. Minor gaps like invalid-path behavior remain, but the essential calling context is present.

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

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

Schema coverage is 100% and the single parameter is already documented as an absolute or ~ path. The description adds only contextual behavior about paths already in the working folder, not additional syntax or semantics 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?

The description states a specific verb and resource ("Abre una presentación") and enumerates supported formats (.key, .pptx, .ppt). It is clearly distinguishable from siblings like crear, leer_presentacion, or cerrar because it describes opening with a copy-on-open workflow.

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 specifies one conditional behavior (if the path is already in the working folder, open that copy directly), but does not say when to use this versus alternatives such as leer_presentacion or crear. Usage is implied rather than explicitly guided.

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 whole burden. It doesn't say whether this mutates an existing slide, whether it replaces current content on the table slide, whether exceeding 8 points errors or truncates, or what a successful call returns. For a write-style layout tool that is a real 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 with the visual result first and the placement constraint second; nothing is wasted. It is perhaps overly terse for the amount of behaviour left unexplained, but the structure and front-loading are good.

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

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

With no annotations and no output schema, the definition should say more about side effects on the target table slide and about what happens when the point count or slide type is wrong. What is present is accurate but leaves an agent guessing on the mechanics of the write.

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 two top-level id/slide parameters are already documented in the schema. The description does add meaning for the puntos array by explaining how numero/titulo/descripcion render, and it restates the max of 8 that the schema already enforces via maxItems. Net value is moderate, not compensating for the undescribed puntos array 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 concretely what it produces: a two-column agenda of up to 8 points, each with a number in the accent color, a title and a description. That is a specific verb-less but resource-rich description an agent can match to a deck-building intent. It does not, however, distinguish itself from near-neighbours like tarjetas_numeradas or diapositiva_contenido.

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?

'Úsala sobre una diapositiva_tabla' gives one concrete application context, which is more than nothing. But it never says when to pick this over the similar numbered-cards or content-slide siblings, nor whether the target table slide must be empty first. Usage is implied rather than framed.

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 burden and does meaningful work: it discloses that insertion is at the end by default, that despues_de=0 means the front, and that a missing layout produces an error enumerating valid layout names. It omits what the tool returns (no output schema) and whether changes are persisted/saved.

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

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

A single dense sentence that front-loads the action and the placement rule, then appends the error-recovery hint. 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 simple 3-parameter mutation with no annotations and no output schema, the description covers placement and failure modes but says nothing about the return value (e.g., new slide index or confirmation) or about persistence, leaving a gap an agent may need to fill empirically.

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%; the one undescribed parameter (despues_de) is explained in the description ('0 = al principio'), which is exactly the kind of value the schema lacks. It also clarifies that diseno is matched by name and that names are discoverable from the error message, adding real meaning beyond the schema text.

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

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

Specific verb ('Agrega') and resource ('una diapositiva con un diseño maestro') with explicit placement scope (end, or after a given slide). It doesn't differentiate from the specialized siblings (diapositiva_portada, diapositiva_contenido, diapositiva_tabla), so an agent can't easily tell when to use this generic adder versus a typed 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?

The placement semantics are stated, but there is no when-to-use guidance relative to the many alternative slide-creation siblings, nor any prerequisite (e.g., presentation must be open). Usage is implied rather than directed.

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

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

No annotations are provided, so the description carries the full burden, and it says nothing about this being a mutating operation, whether changes persist without guardar, what happens when objetos has a single element (schema allows minItems 1), or what the response looks like. Only the geometric effect is 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 compact sentence with the reference frame front-loaded and the mode list in a trailing parenthetical. Nothing is wasted, though the parenthetical enumeration is slightly harder to scan than a short list.

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

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

For a 5-parameter mutating tool with no annotations, no output schema, and a nested objetos array that is undocumented, the description leaves too much open: object addressing, prerequisites, and side effects are all unstated.

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 40%, so the description needs to compensate. It does add meaning for modo (mapping the six enum values to left/center/right/top/middle/bottom) and implicitly for respecto ('entre sí o con la diapositiva'), but it never explains the objetos array structure (tipo/indice pairs) or how indice is scoped.

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 (align objects) plus the two reference frames (relative to each other or to the slide) and enumerates the six alignment modes. An agent can distinguish this from mover_objeto or distribuir_objetos by the description alone, though no sibling is 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?

The alignment semantics imply when to use it, but there is no explicit guidance on when to choose this over distribuir_objetos (spacing) or mover_objeto (free positioning), and no stated prerequisites such as needing the presentation open. Usage is inferable 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?

With no annotations, the description carries the full burden and does disclose the key side effect: a new slide is created (duplication) and the original is left as the start state of the animation. It does not say where the duplicate is inserted, whether the operation is reversible, or what happens on failure, which keeps it from a 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?

A single dense sentence that front-loads the technique name and then enumerates the supported transformations with their units. Nothing is wasted, though the semicolon-chained clause is heavy and could be split for faster 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 complex tool with a nested 'cambios' array and no output schema, the description explains the transformation vocabulary well but says nothing about the result — where the duplicated slide lands, whether an index/id is returned, or what the caller should do next. That gap matters for chaining calls.

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?

Adds real meaning beyond the 75%-covered schema: units for each change field (points for x/y/ancho/alto, degrees for rotacion, 0–100 for opacidad, hex for color_texto) and, importantly, that color_texto only applies to text objects. It does not explain 'tipo'/'indice' pairing or how multiple entries in 'cambios' are matched to objects.

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 technique (Magic Move) and the exact mechanism: duplicates the slide, then moves/scales/rotates/fades/highlights objects in the copy so the transition animates the change. This clearly separates it from siblings like duplicar_diapositiva, mover_objeto and transicion, which only do one piece each.

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?

By explaining that the tool itself duplicates the slide and applies the changes to the copy, it implicitly tells the agent not to chain duplicar_diapositiva + mover_objeto manually. It gives no explicit exclusions or 'use X instead when...' guidance against transicion or mover_objeto, so it stops short of a 5.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses that the tool is a toggle ('o desbloquea'), which the name alone would hide, but says nothing about persistence, permissions, idempotency, or what happens when locking an already-locked object.

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

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

A single front-loaded sentence with zero filler and the core action stated first. It is efficient, though it is arguably too sparse for a 5-parameter mutation tool.

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 five parameters, no annotations, and no output schema, the description should explain how objects are addressed (type + 1-based index within the slide) and what a successful call returns or changes. It leaves both to inference.

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 40%, and the description mentions no parameter by name. The four required parameters (documento, diapositiva, tipo, indice) and the optional bloquear flag are left to the schema; indice and tipo in particular get no explanation of ordering or object identification from the 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?

States a specific verb (bloquear/desbloquear) applied to a concrete resource (un objeto) within a named context (Keynote, edición manual). An agent can distinguish it from mover_objeto or borrar_objeto, 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?

The phrase 'para que no se mueva por accidente al editar a mano' implies the scenario (protect objects before manual edits), but there is no explicit when-to-use/when-not, no prerequisite about the presentation being open, and no guidance on which sibling to pick instead.

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 confirms this is a destructive delete and adds the useful detail that hidden template prototype slides are protected, but omits whether deletion is permanent/undoable, what happens to objects on the slide, and required document state.

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

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

Two short sentences with the core action first and the constraint second. Every sentence earns its place and nothing is 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 destructive mutation tool with no annotations and no output schema, the description should cover irreversibility, side effects, and error conditions. It only notes the prototype-slide protection, leaving the most consequential behavioral facts for the agent to guess.

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 both parameters (documento and diapositiva, with 1-based indexing) are fully documented in the schema. The description adds no parameter-level detail, 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?

States a specific verb+resource: 'Borra una diapositiva' clearly identifies deletion of a slide, distinct from siblings like ocultar_diapositiva or mover_diapositiva. It lacks explicit sibling differentiation, but the operation itself 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?

The only guidance is a constraint ('Los prototipos ocultos de la plantilla están protegidos'), which tells the agent one case that fails. There is no indication of when to delete versus hide (ocultar_diapositiva), whether the operation is reversible, or any 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 carries the full burden. It makes clear the operation is a deletion, but says nothing about irreversibility, undo, confirmation, whether referenced animations or group members are affected, or permission requirements — significant gaps 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?

A single front-loaded sentence with no wasted words. The trailing parenthetical is slightly cryptic but earns its place by tying the parameters to a known sibling format.

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 4-required-parameter destructive mutation with zero annotations and no output schema, the description is too thin: it omits irreversibility, response behavior, and the exact indexing semantics an agent needs to avoid deleting the wrong object.

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 50%: documento and diapositiva are documented in the schema, while tipo and indice are not. The description partially compensates by pointing to leer_presentacion with detail as the reference for how tipo/índice are defined, but it doesn't state whether índice is per-type or global, or what a group index means.

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

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

States a specific verb+resource: 'Borra un objeto de una diapositiva', which distinguishes it from borrar_diapositiva (whole slide) and mover_objeto. Sibling differentiation is implicit but the object-vs-slide contrast is clear enough for selection.

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 parenthetical points the agent to leer_presentacion 'con detalle' as the source of the tipo/índice pair, which implies a prerequisite workflow. However, there is no explicit guidance on when to use this versus mover_objeto, bloquear_objeto, or borrar_diapositiva, and no 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?

With no annotations, the description carries the full burden and does well: it discloses that mixed-format text is skipped to preserve emphasis, that forzar overrides this, that skipped items are reported separately, and that omitting reemplazar leaves the document untouched. It doesn't say whether all occurrences are replaced, how conflicts are reported, or what the response contains.

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 scope, then behavior, then the non-mutating mode. No filler and no repetition of schema content.

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, it covers the main risk (losing formatting) and the mode split. The remaining gap is the return value — 'se reporta aparte' hints at a report but the description never says what is returned or in what shape.

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 29%, so the description must compensate; it explains the semantics of reemplazar and forzar well beyond the bare schema. However, the notas and tablas booleans are only alluded to as search areas, never described as toggles, and buscar/mayusculas add nothing 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 pair (busca/reemplaza) and a precisely scoped resource (toda la presentación), enumerating the object types searched: cuadros, figuras, notas y celdas de tablas. An agent can immediately tell this apart from siblings like editar_celdas or poner_texto.

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?

'Sin reemplazar solo cuenta y no modifica' gives explicit guidance on how to run a non-destructive dry run, and 'con reemplazar, lo cambia' defines the mutating mode. It lacks any exclusion relative to siblings (e.g., when to use editar_celdas or estilo_texto instead), so it stops short of full routing guidance.

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

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

With no annotations, the description carries the burden and does disclose the important default: closing discards changes unless saving is requested. It does not say what happens on an unknown or already-closed document, whether an error is raised, or what the response contains.

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 clauses, front-loaded with the core action and followed by the default behavior and the scope limit. Nothing is redundant, though the phrasing is terse enough to leave 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?

A close-without-saving operation is potentially destructive and has no annotations and no output schema, so the description should explain failure modes and whether unsaved work is silently lost. It covers the default behavior but leaves those operational questions 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 coverage is 50%: documento is documented in the schema, guardar is not. The description partially compensates by stating the default is no-save, which explains what guardar=true would do, but it adds no further detail on the parameter.

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

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

States a specific verb and resource ("Cierra una presentación de Atril") and adds a scope exclusion ("No cierra presentaciones del usuario") that separates it from presentation-editing siblings. It stops short of naming a sibling such as guardar, so it is clear but not fully differentiated.

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?

"por defecto sin guardar" and "No cierra presentaciones del usuario" imply when the tool applies and what it will not touch, but there is no explicit guidance on calling guardar first or on handling unsaved work. Usage must be inferred.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only describes appearance. It doesn't say whether the row is appended to an existing slide, what permissions or state are needed, whether re-invoking duplicates objects, or what happens with the x/y/ancho/alto defaults.

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, front-loaded sentences with no filler, which is appropriately sized. The trade-off is that the terseness comes from describing only styling, not from efficiently conveying the 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?

With 7 parameters, no annotations, no output schema, and near-identical siblings, the description should explain prerequisite state, placement semantics, and differentiation. It supplies only the visual layout and a default color, leaving major gaps for a write operation.

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 43%, and the description covers only a fraction of it: it restates the 1–4 item limit and adds the useful default 'titulo' for the figure color. The four geometry parameters (x, y, alto, ancho) receive no explanation, and y has no schema description at all.

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 (a row of 1–4 highlighted figures/cards) and describes its visual composition, so an agent can infer what gets produced. However, it is a noun phrase with no action verb, and it doesn't distinguish this from the very similar sibling 'tarjetas_numeradas' or from 'diapositiva_contenido'.

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 tarjetas_numeradas, diapositiva_figura, grafica, or a plain content slide. Nothing states that an existing presentation and slide are required, even though documento and diapositiva are mandatory.

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 disclose the key side effect: the file is written immediately as .key into Atril's backups folder, and invalid themes produce a listing error. However it is silent on overwrite/name-collision behavior, whether the new presentation becomes the active document, and where exactly that folder lives.

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: creation behavior first, error recovery second. No filler. Slightly under-specified rather than verbose, but the structure itself is efficient and front-loaded.

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 four-parameter mutating creation tool with no annotations and no output schema, the description covers purpose, persistence location, and one error case, but omits dimensions semantics and collision handling. Adequate to invoke safely with defaults, not complete.

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

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

Schema coverage is only 25% (only "nombre" documented, as filename without extension). The description adds meaningful context for tema (must exist, valid values surfaced via error) but says nothing about alto/ancho — their units, defaults, or relationship to slide aspect ratio — leaving half the surface 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?

States a specific verb and resource ("Crea una presentación nueva") plus the theme and immediate .key save, which distinguishes it from opening or reading an existing presentation. It does not explicitly contrast with the sibling crear_con_formato, 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?

The description never says when to use this versus abrir, crear_con_formato, or other creation paths, nor any preconditions. The only conditional mentioned (nonexistent theme -> error listing available themes) is error behavior, 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 full burden and does well: it discloses the important non-obvious side effect that 6 hidden prototype slides are added at the end and must not be deleted because the diapositiva_* tools depend on them. It doesn't cover permission requirements or what the tool returns, but the critical behavioral detail is front and center.

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 tightly written sentences: the first front-loads purpose and theme elements, the second delivers the critical warning about prototype slides. No wasted words, and the most important operational constraint is prioritized.

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 low-complexity creation tool with one fully documented parameter and no output schema, the description covers the essential purpose and the most dangerous side effect (hidden prototype slides). Minor gaps remain: what happens if 'nombre' is omitted, how the tool relates to sibling 'crear', and whether it opens/returns the presentation.

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 one optional parameter ('nombre') and schema description coverage is 100%, so the schema already documents it fully. The description adds no extra meaning about the parameter (e.g., default naming behavior), so baseline 3 is appropriate.

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: 'Crea una presentación con el formato del tema activo', and clarifies the theme elements (backgrounds, fonts, palette). It implicitly distinguishes itself from the generic 'crear' sibling by emphasizing theme formatting, but it never explicitly contrasts the two.

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 but gives no guidance on when to choose it over the sibling 'crear' (blank presentation) or any other alternative. The only operational rule is about not deleting prototype slides, which is behavioral guidance rather than selection criteria.

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 but only describes the content of the slide. It does not disclose that this is a mutating operation that adds a slide to an existing presentation, that it goes to the end by default (only the schema's despues_de reveals that), or that 'subtítulo en el color de acento' is an automatic styling side effect.

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

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

It is a single short fragment with no waste, and the key content (título 'Gracias', subtítulo, autor) is front-loaded. But it is under-specified rather than concise – a missing verb and missing operational context are not compensated by brevity.

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 6-parameter mutation tool with no annotations and no output schema, the description covers only the visible fields of the resulting slide. It omits the action itself, the required documento, presenter notes, and insertion placement, leaving significant gaps for an agent to fill.

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 50%, and the description partially compensates: it reveals that titulo defaults to 'Gracias' and that subtitulo is rendered in the accent color, which is non-obvious semantics beyond the schema. It says nothing about documento (required), notas, or despues_de, but the schema already documents those three.

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 slide type ('Cierre') and its contents (título, subtítulo, autor), which lets an agent distinguish it from siblings like diapositiva_portada or diapositiva_divisor by convention. However, there is no verb at all – nothing states that this CREATES and appends a slide to a presentation – so the agent must infer the action from the tool family naming pattern.

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 diapositiva_portada, diapositiva_divisor, or diapositiva_contenido, nor any prerequisites (e.g. that a presentation must be open/identified via documento). The agent is left to 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?

No annotations are supplied, so the description carries the burden alone. It does disclose one behavioral trait beyond the schema — that animating bullets produces one-click fade-in entrances — but says nothing about whether the deck is persisted, what is returned (new slide id/index), or what happens on an invalid document 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?

Two compact sentences with the layout enumeration front-loaded and no filler. It is efficient but borders on under-specification, since the opening is a label rather than an action statement.

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 creation tool with no annotations and no output schema, the definition covers the visual layout well but leaves the agent guessing about return value, persistence side effects, and error conditions. Adequate, not complete.

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

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

Schema coverage is 88%, so parameters are already well documented (despues_de default/range, documento source, antetitulo casing). The description adds only marginal meaning — it clarifies that bullets run full width and that the footer is a section footer, and implies page numbering is automatic rather than a parameter. 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 names a specific layout (antetítulo, título, viñetas a todo el ancho, pie, número de página), which lets an agent distinguish it from siblings like diapositiva_portada, diapositiva_divisor or diapositiva_cierre. However it is a noun phrase with no explicit verb — the agent must infer that the tool inserts a new slide into an existing document, and the relationship to the generic sibling agregar_diapositiva is not 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?

There is no statement of when to use this versus the other slide-creation siblings (agregar_diapositiva, diapositiva_portada, diapositiva_figura, diapositiva_tabla, agenda), nor any prerequisite such as the document having to exist or be open. The only conditional hint is 'Con animar_vinetas, cada viñeta entra con un clic', which explains an option rather than when to pick the 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 provided, so the description carries the full behavioral burden. It describes the visual layout but does not state that it creates a slide, where the slide is inserted by default, what permissions are needed, or what the tool 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?

It is a single front-loaded sentence with no wasted words. The core visual composition is stated immediately.

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 slide-creation tool with no annotations and no output schema, the description is too thin. It covers visual appearance but omits the required presentation identifier, insertion behavior, presenter notes, and return 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?

Schema description coverage is 67%, and the description adds visual meaning for numero, titulo, and subtitulo. However, it does not mention the required documento parameter or explain notas and despues_de, leaving gaps for an agent invoking the 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?

It identifies the exact slide type to create: a section divider with a large number in the accent color, title, and subtitle. This distinguishes it from sibling slide types such as diapositiva_portada, diapositiva_contenido, and diapositiva_cierre, though it lacks an explicit verb like "crear" or "insertar".

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

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

The description gives no guidance on when to use this tool versus alternatives such as diapositiva_portada, diapositiva_contenido, or diapositiva_cierre. It implies usage only through the slide type name and visual composition.

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. The description adds useful behavioral detail: white-card layout, left figure/right bullets with body, full-width without body, aspect-ratio preservation, and a conditional source-caption requirement; however, it does not state that it creates/mutates a slide, side effects, permissions, or error behavior.

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

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

The description is short and mostly front-loaded, moving from the core figure card to layout conditions and image behavior with no filler. The opening is a noun phrase rather than an explicit action statement, so it is not quite a 5.

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

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

For a 10-parameter creation tool with no annotations and no output schema, the description covers the visual output and an important conditional rule but omits creation semantics, return behavior, and selection guidance. The schema supplies most parameter details, so it is minimally adequate rather than complete.

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

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

Schema coverage is high, but the description adds meaning beyond the schema for key parameters: cuerpo changes the composition, origen may be obligatory depending on topic, and imagen is proportion-preserving. It still leaves several params to the schema, so it is not fully self-contained.

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 a figure slide on a white card and makes the with/without-body layouts concrete, so an agent can tell it is the figure-oriented slide creator. It lacks an explicit action verb and does not name sibling alternatives, which keeps it below 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?

It gives a conditional rule for when the source caption is obligatory and explains how body content changes layout, but it does not say when to choose this tool over diapositiva_contenido or other slide-creating siblings, nor does it list 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 must carry the full behavioral burden, but it only describes the visual result. It does not state that this mutates the presentation by adding a slide, how insertion order works, what permissions or document state are required, or what happens on failure.

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 description is front-loaded and wastes no words, but it is under-specified for a seven-parameter mutation tool. Its brevity reflects missing action and usage context rather than tight completeness.

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

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

For a no-annotation, no-output-schema mutation tool with seven parameters, the description is incomplete. It omits the action of creating a slide, the required documento parameter, insertion behavior via despues_de, notes handling, and any side effects or prerequisites.

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 57%, and the description adds visual meaning for four fields: antetítulo, título, subtítulo, and autor. It does not clarify the important documento, notas, or despues_de parameters, which are only partly described in 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 identifies the slide type as a cover slide and enumerates its visual elements (pre-title, large title, italic subtitle, author). However, it never explicitly states that the tool creates or adds a slide to a presentation, and differentiation from sibling slide types relies mostly on the tool name.

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 this tool versus alternatives such as diapositiva_contenido, diapositiva_divisor, or diapositiva_cierre. It also omits prerequisites like needing an open or created presentation.

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 discloses the output slide composition (white card, source footer, title from filename or titulos) and the one-slide-per-image behavior, but omits mutation side effects, presentation state prerequisites, insertion behavior, and error/return behavior.

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

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

The description is short and front-loaded with the core rule, 'Una diapositiva por imagen'. The parenthetical efficiently packs the figure-slide details, though 'el formato' is an underspecified reference.

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

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

For a creation tool with 7 parameters, no annotations, and no output schema, the description is incomplete. It does not explain the required documento and imagenes parameters, the despues_de insertion behavior, antetitulo, or what 'usa el comando de Keynote' entails.

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 57%, so some compensation is expected. The description clarifies titulos (title from filename or titulos) and references 'pie de origen', but does not explain antetitulo or the required documento/insertion semantics beyond what the schema already provides.

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 the core behavior clearly: 'Una diapositiva por imagen', and distinguishes the result as a diapositiva_figura when using 'el formato'. The undefined phrase 'el formato' keeps it from being a 5, but the resource and outcome are understandable.

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?

Describes a mode-dependent outcome rather than when to use this tool versus alternatives. It names no sibling alternative explicitly, and the 'en otras presentaciones usa el comando de Keynote' fallback is vague, leaving the agent to infer the selection criteria.

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. It does disclose one genuinely useful behavioral contract — the content area is left empty so later tools (tabla, ecuacion, forma) fill it. It omits, however, that this is a mutating create operation, what it returns (presumably a slide handle), and whether anything existing is affected.

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 dense sentence with zero filler, front-loading the resource and then the layout fields. The semicolon-clause structure is efficient, though the omission of the verb means brevity came at some cost to action clarity.

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 6-parameter mutation tool with no annotations and no output schema, the description covers the layout contract but not the creation semantics, return value, or ordering behavior. The rich schema partially compensates, leaving a definition that is adequate but not self-sufficient.

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 83%, so the schema already documents documento, antetitulo, pie, notas and despues_de. The description only restates the three text slots (antetítulo, título, pie) and adds nothing about notas, documento, or insertion positioning. Baseline 3 for high-coverage schemas is correct 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 specific resource and its layout anatomy (antetítulo, título, pie de sección, free content area), which distinguishes it from diapositiva_contenido/diapositiva_figura by the empty body slot. However, no explicit creation verb appears — it reads as a layout spec rather than 'creates a table slide', so the action is inferred from the name and 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?

Usage is only implied: the free content area is said to be 'para tabla, ecuacion, forma, gráficas o componentes', hinting this is the shell you pick before dropping in a table. It never states when to choose this over diapositiva_contenido or diapositiva_figura, nor that a presentation must be open / that the slide is appended by default.

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 real behavioral traits: the video loops, the source caption ('origen') is mandatory, and the observation panel is constrained to 2–3 bullets. However, it never states that the call mutates the deck, where the slide is inserted by default (the 'despues_de' behavior is only in the schema), or what happens on invalid input.

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 dense sentence that front-loads the slide identity and then enumerates the layout zones in reading order. Nothing is padded, though the 'mazo v3' jargon assumes template familiarity the reader may not have.

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 no annotations and no output schema, the description explains the visual layout but omits the essentials an agent needs to call it safely: that it creates and inserts a slide into a specific presentation, the default insertion position, and whether the deck must be saved afterward. Layout detail is rich; operational context is thin.

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?

At 56% schema coverage, the description adds meaning for roughly four of nine parameters: 'origen' is flagged as obligatory, 'observar' gets a content hint ('QUÉ OBSERVAR') and a bullet count, and 'antetítulo' is implied to be fixed to 'ANIMACIÓN'. The five remaining parameters ('documento', 'titulo', 'pie', 'notas', 'despues_de') receive no elaboration, and the stated '2–3 viñetas' is looser than the schema's minItems 1 / maxItems 4.

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 specific resource — a video slide of the 'mazo v3' template — and spells out its three zones (antetítulo ANIMACIÓN, looping video on a white card with a mandatory source caption, and 'QUÉ OBSERVAR' bullets), which distinguishes it from diapositiva_figura, diapositiva_tabla and insertar_medio. The creation/insertion verb is only implicit in the noun phrase, and the 'documento' target is never mentioned, so it falls short of a fully self-contained purpose statement.

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-to-use guidance and no named alternative, even though insertar_medio and diapositiva_figura are plausible competitors for placing media on a slide. The agent must infer that this tool is the one to call when the deck needs a video slide in the v3 template.

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 behavioral burden. It usefully discloses that spacing is equal and that the first and last objects do not move, but it omits whether this mutates positions, what happens on failure, permissions, or any return 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 front-loaded sentence that states the action, constraint, axis options, and key invariant with no wasted 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 core operation is adequately described, but for a mutation tool with no annotations and no output schema, the description lacks usage alternatives, error/edge-case behavior, and clarification of object ordering. It is sufficient to attempt a call but not fully complete.

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

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

The schema describes 'documento' and 'diapositiva', while the description adds meaning for the undocumented parameters: at least 3 objects, horizontal/vertical axis, equal spacing, and fixed endpoints. It could further clarify that 'primero' and 'último' correspond to the order in the 'objetos' array.

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 clear verb and resource: 'Reparte ... objetos' with equal spacing in horizontal or vertical direction. It does not explicitly name or distinguish itself from the sibling tool 'alinear_objetos', so it stops short of full sibling differentiation.

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 this tool versus alternatives such as 'alinear_objetos' or 'mover_objeto'. The mention of '3 o más objetos' and axis options are constraints, 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?

No annotations exist, so the description carries the full burden. It usefully discloses that the copy is an independent object set editable via mover_objeto and that the original remains untouched for the transition, but it omits whether the response returns the new slide index, whether notes/animations are copied, and whether an open document is required.

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

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

Two tight sentences, zero filler. The core behavior is front-loaded and the workflow hint follows it rather than burying it.

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 two-parameter, non-destructive structural tool with no output schema, the description covers what it does and how it fits the Magic Move pattern. The main residual gap is return value (new slide number) and whether slide content such as notes or animations is carried over.

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%, so both parameters (documento, diapositiva) are already documented with examples and 1-based indexing. The description adds nothing parameter-specific beyond the concept of a source slide, 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?

States a specific verb and resource (duplicar una diapositiva) and adds the key placement semantic: the copy lands immediately after the original. This clearly distinguishes it from agregar_diapositiva, though it never names that sibling explicitly as the alternative.

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?

Frames the tool as the first step of a Magic Move workflow and names the concrete follow-up actions (mover_objeto on the copy, magic move transition on the original). It gives clear context for when to reach for it, but offers no exclusion conditions or prerequisites (e.g., presentation must be open).

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 useful traits such as vector-image output, default title color, sizing without ancho, and centering without x, but it omits side effects, permissions, layering, and return behavior.

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

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

The description is compact, front-loaded, and information-dense. Every sentence contributes either rendering details, default behavior, or syntax 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 9-parameter drawing tool with no annotations and no output schema, the description covers the core equation-rendering behavior but leaves notable gaps around y positioning, package usage, object side effects, and response details.

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 56%, so the description needs to add meaning, and it does: it explains x centering, ancho vs. font-size behavior, default color, and LaTeX display-mode syntax. It still leaves y and paquetes largely unexplained, but the added semantics are meaningful.

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 clearly states that it renders a real LaTeX equation as a vector image, including amsmath/display-mode details. It identifies the resource and output format well, but it does not explicitly differentiate itself from nearby content/graphics 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?

It gives some practical usage guidance, such as using aligned for multiple lines and the default centering behavior when x is omitted. However, it does not say when to choose this over alternatives like poner_texto or grafica_cientifica, nor does it state 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 provided, the description carries the full disclosure burden. It does add one real behavioral trait — "los valores quedan como texto" (values are coerced to text) — but says nothing about overwriting existing content, behavior on out-of-range indices, permission requirements, or reversibility of the change.

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 action front-loaded and the indexing clarifications in a parenthetical. Nothing is wasted, though the parenthetical slightly buries the important index-discoverability hint.

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 4-parameter mutation tool with no annotations and no output schema, this is adequate but thin. The cross-reference to leer_presentacion covers index discovery, but there is no statement of what happens on invalid rows/columns or whether the call replaces or appends within a cell.

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 has to compensate, and it does meaningfully: it defines the table index by cross-referencing leer_presentacion "con detalle" (which is how an agent discovers valid indices) and clarifies that fila and columna are 1-based, reinforcing the minimum:1 constraints.

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?

"Cambia celdas de una tabla existente" states a specific verb (cambia) and resource (celdas of an existing table), which is enough to distinguish it from table-creation siblings like tabla or tabla_estructura. It does not, however, explicitly separate itself from text-editing tools such as poner_texto.

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 "tabla existente" implies a prerequisite (the table must already exist), but there is no explicit when-to-use vs. when-not, no mention of the sibling that creates tables, and no guidance on what to do if the target table is missing.

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 that the tool modifies existing text and can target either all text or a paragraph, but it does not state whether unspecified style properties are preserved, whether changes are reversible, what happens if índice is invalid, or whether any permissions/conditions apply.

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 with the main action and then lists the relevant style dimensions efficiently. It is dense but contains no filler, though the parenthetical provenance note slightly interrupts the flow.

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, no output schema, and only 40% schema description coverage, the description leaves too much unspecified. It helps with style parameters and the source of tipo/índice, but does not fully explain required identifiers, enum semantics, preservation behavior, or failure conditions.

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

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

Schema coverage is only 40%, so the description needs to compensate. It adds meaning for several style parameters (fuente, tamaño, color, negrita, cursiva) and clarifies that parrafo selects a paragraph versus all text, but it does not explain the tipo enum values, the meaning of índice, or how documento/diapositiva are interpreted beyond what the schema already says.

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+resource: changing the style of existing text, and enumerates the style properties it can modify. It implicitly distinguishes itself from insertion tools like poner_texto by specifying 'texto existente', but it does not explicitly name or differentiate against any sibling tool.

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

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

It gives a useful provenance hint that tipo and índice come from leer_presentacion con detalle, and the 'texto existente' wording implies this is for restyling, not inserting text. However, it does not state when to use this versus alternatives such as poner_texto or crear_con_formato, nor does it mention exclusions or prerequisites beyond the source of identifiers.

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 so well: it discloses where output lands, that existing destinations are never overwritten but suffixed _2/_3..., that PNG/JPEG and HTML produce folders rather than files, that GIF requires ffmpeg, and that video is 1080p with transitions. These are exactly the side-effect and dependency facts an agent needs before invoking.

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 that front-load the format list, then the destination behavior. The enum enumeration is long but earns its place as the tool's core capability; a reader can stop after the first clause and still call it correctly.

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

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

For a 5-parameter, annotation-free, mutation-producing tool the description covers formats, side effects, collision handling, and external dependencies. The remaining gap is the return value (e.g., resulting file path) which, absent an output schema, the description could have stated.

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 80%, so the baseline is 3; the description goes beyond it by clarifying that the same destino argument means a file for pdf/pptx but a folder for png/jpeg/html, and that image export yields one file per visible slide. It does not touch etapas or con_notas, but the schema already documents those.

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?

Opens with a precise verb plus resource ("Exporta la presentación") and immediately enumerates every supported target format, which matches the formato enum exactly. An agent can distinguish this from siblings like guardar or presentar without opening the 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?

Conveys useful operating context (default output folder, non-destructive naming) but never states when to reach for this tool versus alternatives such as guardar (save) or presentar (run the show). The choice is inferable from the name, but no explicit routing 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 carries the full burden and does disclose useful behavior: defaults ('relleno tarjeta con borde; líneas en el color de acento'), the 'ninguno' sentinel for relleno/borde, opacity range 0–100, and that text is drawn centered over the figure. It stays silent on permissions, z-ordering, return value, and what happens with invalid coordinates or a missing document.

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 dense paragraph, but every clause carries information an agent needs for a 21-parameter tool: the shape list comes first, then geometry, then styling, then defaults. Nothing is redundant with the schema and nothing is padding.

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 21-parameter mutation tool with no annotations and no output schema, the definition covers shape semantics and styling defaults but omits the radius parameter, how estilo_texto interacts with plain texto, whether the created object can be referenced later, and whether the presentation must already be open. Adequate but with clear holes.

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 29% across 21 parameters, but the description compensates well: it maps coordinate groups to shape families (x/y/ancho/alto vs x1/y1/x2/y2), explains enum-dependent meanings (lados = polygon sides or star points, cola = speech-bubble tail, elipse becomes a circle when ancho = alto), and documents relleno, borde, grosor, opacidad, punteado and texto, all of which lack schema descriptions. Gaps remain for radio and estilo_texto interactions.

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 (a vector figure using the format's palette) and enumerates every shape type it can draw, so an agent knows exactly what is produced. It has no real verb ('Figura vectorial con…') and never distinguishes itself from sibling tools like linea or diapositiva_figura, which is why it falls short of a 5.

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

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

There is no statement of when to use this tool versus alternatives, even though siblings such as linea, diapositiva_figura or alinear_objetos overlap heavily. The implicit overlap is not resolved – the description even lists 'linea' and 'flecha' as tipos here while a separate 'linea' tool 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?

Sin annotations, la descripción aporta contexto conductual: estilo nativo con colores del tema, leyenda y ocupación por omisión del área de contenido, además de restricciones de datos por tipo. Sin embargo, no aclara efectos secundarios, permisos, si reemplaza objetos existentes ni qué devuelve.

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?

Está front-loaded y usa pocas frases, pero enumera los 17 tipos que ya aparecen en el enum del esquema, lo que añade redundancia y alarga la descripción. La estructura es funcional, aunque no es la más económica.

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?

Para una herramienta de 10 parámetros, sin annotations ni output schema, cubre el modelo de datos y los tipos de gráfica, pero deja sin explicar los parámetros de posición/tamaño y el comportamiento de inserción o retorno. Es suficiente para el núcleo, no completa para toda la complejidad.

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?

Con cobertura de esquema del 50%, la descripción compensa bien los parámetros complejos: explica que en barras/línea/área cada serie trae un valor por categoría, que pastel usa una sola serie y una porción por categoría, y que dispersión usa valores_x compartidos sin categorías. No cubre la semántica de x, y, ancho y alto, pero el núcleo del modelo de datos queda claro.

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?

Describe una gráfica nativa de Keynote con colores del tema y leyenda, y detalla la forma de los datos por tipo de gráfica. Es claro qué recurso produce, pero no usa un verbo explícito ni diferencia esta herramienta de grafica_cientifica.

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 indica cuándo usar esta herramienta frente a grafica_cientifica, tabla u otras alternativas, ni menciona prerrequisitos. Solo describe la forma de los datos por tipo, lo que ayuda a invocarla pero no a elegirla.

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 behavioral burden. It does disclose real side effects: creating a new diapositiva_figura card with an origin footer, versus drawing on top of an existing slide with theme text colors and a transparent background. However, it never says the document must be open/selected, whether the operation is reversible or how to undo it, nor what the call returns (a slide index? an object id?), despite being a document 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?

The core identity and the capability list come first, followed by the two modes and finally the sibling alternative — a sensible front-loaded order with no filler sentences. The capability enumeration is dense but every item corresponds to a real parameter, so little is wasted; it could still be tightened into grouped clauses.

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 22-parameter, deeply nested tool with no output schema and 45% schema coverage, the description covers the drawing modes and feature set but leaves the agent without the two required inputs' role (documento must reference an open presentation, series must be non-empty), the positioning semantics, or any return-value expectation. Adequate for a first call, incomplete for confident invocation.

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 45% across 22 parameters, so the description needs to compensate. It does map several features to parameters implicitly (error bars symmetric/asymmetric, 'cotas superiores' → limite_superior, escalas → escala, 'bandas de confianza' → banda/y_inf/y_sup, histogramas → valores/bins, segundo eje → eje_y2, lineas_ref, anotaciones), but explains nothing about x/y placement, alto/ancho, leyenda, rejilla, despues_de or tamano_texto defaults. Useful but partial.

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

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

States a specific verb and resource (scientific chart rendered via matplotlib into vector PDF with theme palette) and enumerates concrete capabilities: error bars, upper-limit arrows, log/symlog scales, inverted axes, confidence bands, histograms, second y axis, reference lines, annotations. It explicitly separates itself from two siblings: 'grafica' for what Keynote draws natively (bars, pie, editable) and 'ecuacion' for the Computer Modern formula rendering used in $…$.

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 an explicit alternative and the condition that selects it: 'Para lo que Keynote sí dibuja bien (barras, pastel) usa grafica, que es editable.' It also defines the two operating modes with their conditions — without 'diapositiva' it creates a new diapositiva_figura; with 'diapositiva' it draws over the existing slide in the content area.

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 does add real behavioral context: destination (.key in the copies folder) and the fact that new/imported files get a fresh copy rather than overwriting. Incomplete on error behavior and return value, but the core write semantics 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 sentences, front-loaded with the action and destination, then the scoping clause. Efficient with minimal waste, though the second sentence is a bit easy to misread.

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?

Covers what it does and where files land, but for a save/mutation tool with no annotations and no output schema, it leaves gaps around failure modes and how to interpret the resulting copy. Adequate but not fully complete.

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

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

Schema description coverage is 100%, so the schema already documents 'nombre' and 'documento'. The description adds nothing about parameter formats or behavior, so the baseline 3 is appropriate.

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 (guarda) and resource (presentación de Atril) plus a concrete outcome: saved as .key in the copies folder. Distinguishes scope from user files via 'nunca guarda presentaciones del usuario', though this negative clause reads slightly ambiguously against the main action.

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

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

Gives clear context for when it applies (new or PowerPoint-imported presentations get a new file) and an explicit exclusion ('nunca guarda presentaciones del usuario'). It stops short of naming an alternative tool (e.g. exportar) for saving user work, so routing is left partly inferential.

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 usefully discloses that the result is cardless, that height is derived from the file's aspect ratio, and that the source file is only read — but it says nothing about whether the slide must already exist, what happens on unsupported formats, or what object is created.

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 tightly packed sentences with zero filler: formats first, the sibling exclusion second, the aspect-ratio behavior last. Nothing is repeated from the schema or the 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?

For an 8-parameter mutation tool with no annotations and no output schema, the description covers purpose, formats, aspect ratio and one exclusion. It does not cover positioning behavior, defaults for the optional x/y/ancho, or what the call yields, leaving meaningful gaps.

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

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

Schema coverage is 63%, so the schema documents roughly half the parameters. The description adds genuine value by explaining why there is no height parameter ('El alto sigue la proporción del archivo') and by constraining archivo to image/video/audio formats, but it says nothing about x/y positioning or ancho semantics.

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 ('Inserta') plus the exact resources handled (imagen, video, audio) and the target container (una diapositiva), and enumerates accepted video extensions. It explicitly distinguishes itself from the sibling diapositiva_figura, so an agent can separate the two without opening either 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?

Gives an explicit exclusion and the alternative to use instead ('sin tarjeta … usa diapositiva_figura'), which is real routing guidance. It leaves one obvious ambiguity unaddressed: the sibling diapositiva_video is never mentioned, so when to prefer this tool over that one must be inferred.

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?

Annotations already mark this as readOnlyHint=true, so the safety profile is covered. The description adds valuable behavioral detail beyond annotations by enumerating the returned slide fields and explaining the expanded object-level result when detalle=true.

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 are front-loaded with the main read behavior and then the detalle=true variant. The listing is dense but every enumerated field contributes to understanding the return shape.

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 carry return-value context. It does so for both the default slide-level mode and the detalle=true object-level mode, which is sufficient for an agent to understand what will be returned.

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%, with documento, desde and hasta already documented in the schema. The description adds important meaning for the otherwise undocumented detalle parameter and explains that object indices are intended for use with poner_texto.

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: reads a presentation slide by slide, including layout, skipped state, title, body, notes, transition, object counts and texts. It clearly describes the detalle=true variation, but does not explicitly distinguish itself from sibling tools such as ver_diapositiva.

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

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

The description gives useful usage context by explaining when detalle=true should be used and by linking returned object indices to poner_texto. It does not state when to prefer this over ver_diapositiva or other presentation-reading siblings.

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

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

With no annotations, the description carries the full burden, and it does disclose a real behavioral limitation: color and thickness come from the theme and cannot be set by script. It remains silent on mutability of the line afterwards, permissions, and what (if anything) is returned or how the object is identified.

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 theming caveat follows immediately. Nothing is 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?

No output schema and no annotations, so the description must cover more, yet it omits whether the line can later be moved/selected, whether it needs an existing slide, and any return value. It is adequate for invocation but not complete for a mutation tool with six required params.

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%, but the description usefully clarifies that coordinates are measured in points, which the schema does not state. The four coordinate parameters (x1/y1/x2/y2) still lack any explanation of ordering or whether they are slide-relative.

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 action and resource: a straight line between two points, with coordinates measured in points. It does not name or distinguish itself from related siblings such as forma, diapositiva_figura, or alinear_objetos, so an agent must infer that this is the plain-geometry primitive.

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 this versus forma or diapositiva_figura, nor any prerequisite about the slide already existing. The only contextual statement is a constraint (theme controls color/thickness), which is not usage 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?

Annotations already declare readOnlyHint=true, so safety is covered, but the description adds genuinely operational context: editable=false means the deck belongs to the user and is read-only, which tells the agent it cannot mutate that presentation. It does not cover ordering of results or what happens when nothing is open.

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

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

A single sentence with the action front-loaded and the returned fields following. The parenthetical about editable=false is dense but every clause carries information; 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?

There is no output schema, so the description carries the burden of describing what is returned, and it does so field by field, including the non-obvious editable flag. Missing only edge cases such as empty results and ordering for a simple zero-argument read 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?

Zero parameters, so baseline is 4. The description usefully interprets one of the returned attributes (editable) rather than any input, which is the best available use of the space.

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 ('Lista las presentaciones abiertas en Keynote') and then enumerates the returned fields, so the agent knows exactly what comes back. It is implicitly distinct from siblings like leer_presentacion or abrir, but never names them explicitly, so it stops short of a 5.

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

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

The natural use case (discover what is currently open before calling leer_presentacion or abrir) is implied by the description and the sibling set, but there is no explicit when-to-use or when-not-to-use statement, and no alternative is named.

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

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

With no annotations, the description carries the full burden. It usefully discloses the sentinel case (0 = at the beginning) and that the new slide number is returned, but does not explain what happens to the indices of intervening slides, whether the operation requires the presentation to be open, or any failure mode for out-of-range positions.

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, both load-bearing: the first defines the operation and its positioning semantics, the second defines the return value. Nothing is wasted and the core behavior is front-loaded.

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 three-parameter mutation with no annotations and no output schema, the description covers what it does, the zero-index special case, and the return value. Only the side effects on surrounding slide indices are left unstated.

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 one undocumented parameter, despues_de, is exactly the one the description clarifies with "0 = al principio", which the bare minimum:0 schema alone would not make obvious. The description reinforces that diapositiva is the slide being relocated.

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 ("Mueve una diapositiva") plus the precise target position semantic ("para que quede después de otra"). An agent can distinguish it from mover_objeto and duplicar_diapositiva, though no sibling is 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 implied by the definition — reorder a slide relative to another — but there is no explicit when-to-use, when-not-to-use, or reference to alternatives such as duplicar_diapositiva or mover_objeto. The agent must infer the reordering 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 provided, so the description carries the full burden. It implies mutation by saying the tool moves, resizes, or rotates an object, but it does not disclose prerequisites, whether the presentation must be open, how locked objects behave, whether changes are saved, or what the result 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?

The description is a single sentence and front-loads the core action. It is efficient with no wasted text, though its terseness leaves important details unstated for a complex 9-parameter mutation tool.

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 9 parameters, no annotations, no output schema, and only 44% schema description coverage. The description gives the basic purpose and object identification but is not complete enough about behavior, prerequisites, parameter semantics, or return effects for reliable invocation.

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 low at 44%, and the description adds some meaning by mapping operations to parameters and by saying the object is identified by tipo and indice as in leer_presentacion con detalle. However, it does not clarify y, alto, ancho, optionality, or constraints, so it only partially compensates for the schema gap.

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

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

The description gives specific verbs and resource: "Mueve, redimensiona y/o gira un objeto". It also identifies the object by type and index, referencing leer_presentacion con detalle, so the agent can understand what the tool does, though it does not explicitly contrast with siblings like alinear_objetos or distribuir_objetos.

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

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

There is no when-to-use guidance, no exclusions, and no mention of alternatives such as alinear_objetos, distribuir_objetos, or bloquear_objeto. Usage is only implied by the operation names, so the agent must infer the appropriate 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 provided, so the description carries the full burden. It does disclose the key behavioral trait that supplying texto mutates/overwrites existing notes ('reemplaza'), which is valuable safety context. It does not say what happens to prior content on empty input, whether the replacement is reversible, or what a read returns when a slide has no notes.

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 well-formed sentence that front-loads the primary (read) behavior and appends the mutation branch. Zero 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?

With three simple parameters, no annotations and no output schema, the description covers the call mechanics adequately. However, it leaves the return value of a read (notes string? empty? null when unset?) and edge cases like empty or very long text unaddressed, which an agent would need for a mutation-capable 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%: 'documento' and 'diapositiva' are documented in the schema, and the one undocumented parameter, 'texto', is exactly the one the description explains via the conditional clause. That is meaningful compensation for the coverage gap, though it stops short of stating accepted formatting or length limits for the notes text.

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?

Names the concrete resource ('las notas del presentador de una diapositiva') and both verbs (lee / reemplaza), so an agent knows exactly what the tool touches. It does not need sibling differentiation because no other tool in the list operates on speaker notes, so this is clear but not maximal.

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 conditional 'si se da texto, las reemplaza' explicitly tells the agent which mode applies: omit texto to read, supply it to overwrite. That is a usable when-to-do-what rule, though there are no exclusions or prerequisites (e.g. whether the slide must already exist, whether empty string clears the notes).

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 present, the description carries the full disclosure burden. It does disclose the key effect (hidden slides are neither presented nor exported) and implies reversibility through 'vuelve a mostrar', but it says nothing about what the tool returns, whether the operation is idempotent, or what happens with an out-of-range slide number.

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; the action comes first and the consequence second, so the agent gets purpose and effect immediately.

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

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

For a mutation tool with no annotations and no output schema, the definition covers purpose and visible effect but leaves gaps around return value and error behavior. It is adequate for a simple toggle but not complete.

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

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

Schema coverage is 67%: documento and diapositiva are already documented in the schema, but ocultar is not described there. The toggle phrasing 'Oculta o vuelve a mostrar' indirectly conveys the boolean's meaning, yet the default of true and the false-branch behavior are never stated explicitly.

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 specific resource (diapositiva) and a toggle action (ocultar / volver a mostrar), which is unambiguous. It does not explicitly distinguish itself from the nearest sibling, borrar_diapositiva, so an agent must infer the hide-vs-delete boundary from the effect clause rather than being told.

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 clause 'Las ocultas no se presentan ni se exportan' implies the use case (removing a slide from a presentation/export without deleting it), but no explicit when-to-use vs when-to-delete guidance or named alternative is given. Usage is inferable 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?

With no annotations, the description carries the full behavioral burden. It implies mutation and explains the bullet-per-line behavior for 'cuerpo', which is useful, but it does not say whether supplying 'titulo'/'cuerpo' overwrites existing content, whether the operation is reversible, or what happens if the target slide has no matching placeholder. Those are significant gaps for a write tool with zero annotation coverage.

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 dense sentence that front-loads the core action and then qualifies it with the three modes; every clause adds information. It is slightly overloaded with parentheticals, but nothing is redundant.

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 6-parameter tool with nested objects, no annotations and no output schema, the description covers the main modes but omits key operational facts: that at least one of titulo/cuerpo/reemplazar/nuevo_cuadro must be supplied, overwrite semantics, and units for the new text box dimensions. An agent can attempt a call but may guess wrong on these points.

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%, but the description compensates well: 'cuerpo' is defined as bullet-per-line text, 'reemplazar' entries are tied to the tipo/indice pairs reported by leer_presentacion, and 'nuevo_cuadro' coordinates are stated to be in points. The remaining gap is that alto/ancho units and the semantics of the 'tipo' enum ('texto' vs 'figura') are left implicit.

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 ('Escribe texto en una diapositiva') and then enumerates the three distinct operations it can perform: filling the layout's title/body, replacing existing object text, and/or adding a new text box. This lets an agent distinguish it from siblings like estilo_texto (formatting) or buscar_reemplazar (search/replace across the deck) 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 'y/o' phrasing makes clear the three modes can be combined in one call, and it explicitly points to leer_presentacion (with detail) as the source of the 'tipo' and 'indice' values needed for replacement — a concrete prerequisite. It stops short of naming when to prefer an alternative (e.g. estilo_texto or crear_con_formato), so it is clear context without 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 burden and does disclose the key side effect that it takes over the user's screen. It does not explain prerequisites such as having a document open, what detener does afterward, or error behavior.

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

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

Two tight sentences: first the action set, then the critical screen-occupation warning. No wasted wording and the safety constraint is front-loaded after the purpose.

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

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

For a stateful UI-control tool with no annotations and no output schema, the description covers the main selection risk: full-screen impact and user-request requirement. It is largely sufficient, though it could say more about required state and stopping 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 description enumerates the accion values and implies desde applies when starting; the schema already covers those details, plus documento. With 67% schema description coverage, the description adds some mapping but does not fully compensate for remaining gaps.

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?

Names the specific domain (Keynote presentation mode) and enumerates the exact actions: iniciar, siguiente, anterior, detener. It is clearly distinct from editing siblings, though it does not explicitly name an alternative tool.

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

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

Provides a strong explicit gating condition: 'úsalo solo si lo pidió' because it occupies the user's screen. It lacks named alternatives for non-presentation viewing, but the when-to-use constraint is clear.

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 key non-obvious behavior: it inserts partial copies of the slide into the deck and leaves the original as the final state. That mutation side effect is genuinely valuable. It stops short of noting reversibility, how many slides are created, or what is returned.

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

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

Three front-loaded sentences with no filler; the mechanism and the index-sourcing rule each earn their place. Slightly dense, but appropriate for the operation's complexity.

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?

Covers the mechanism, index sourcing and the slide-duplication side effect, which is the core need. With no annotations and no output schema, it should still address what the call returns and how it interacts with pre-existing animations — gaps that matter for a deck-mutating 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 75% and the description adds real meaning for the complex nested `pasos` parameter (each step = one or more objects) and its index provenance. `documento`, `diapositiva` and `duracion` are already documented in the schema, so nothing critical is missing.

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

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

States a specific verb (animate/reveal) and mechanism: objects appear in `pasos` order via Magic Move, with partial slide versions inserted before the original. This is clear enough to distinguish from generic animation, though it never names the close siblings `animar_cambio` or `revelar_series` to disambiguate.

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 one useful precondition — indices must come from `leer_presentacion` with detail on the full slide — but never says when to choose this over `animar_cambio` (transition animation) or `revelar_series` (chart-series reveal). 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?

With no annotations, the description carries full burden. It usefully discloses two non-obvious behaviors: Magic Move between slide copies (implying slide duplication) and axis rescaling between steps because the max can't be fixed by script. It omits how many slides are created, reversibility, and auth/permission needs, leaving meaningful gaps for a mutation-style 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?

Two dense sentences, front-loaded with the core concept and then the type/axis caveat. Efficient and waste-free, though the parenthetical is slightly technical.

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 tool with no output schema and no annotations at 40% schema coverage, the description is too thin. It conveys the key concept and one limitation but leaves placement, category handling, and duration behavior 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 coverage is only 40% across 10 parameters. The description clarifies 'tipo' options and 'series' semantics, but says nothing about placement (x/y/alto/ancho), 'categorias', or 'duracion', leaving several undocumented parameters to the schema 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?

States a specific verb+resource: an animated chart where series enter one by one via Magic Move, restricted to bar/line/area types. This clearly separates it from static chart siblings like 'grafica' or 'grafica_cientifica', though it doesn't name them 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 implied by 'series entran una por una' and the type restriction, so an agent can infer it's for sequential series reveal. But there is no explicit when-to-use/when-not guidance or reference to alternatives such as revelar_por_pasos or grafica.

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?

Annotations already declare readOnlyHint=true, and the description adds substantive context beyond that: results are grouped by severity, it estimates effective shrunk body size, contrast is measured against the actual background, and it also emits a sheet with all slides. It does not mention runtime cost despite scanning the whole deck, which keeps it out of 5 territory.

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 verb and scope come first, followed by a dense but purposeful enumeration of checks; every clause names a distinct defect class. The middle sentence is long, but none of it 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?

With no output schema, the description carries the burden of describing returns, and it does: severity-grouped issues plus a slide sheet. It leaves the exact issue record format unspecified, but an agent has enough to call it and interpret the results.

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?

Only one parameter, but schema description coverage is 100% and it already explains that the id can come from listar_presentaciones_abiertas, abrir, or crear, or be an exact name. The description adds nothing about the parameter, 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?

Opens with a specific verb+resource ("Revisa todas las diapositivas visibles y reporta problemas por gravedad") and enumerates the exact checks it performs, which clearly separates it from read-only siblings like ver_diapositiva or leer_presentacion.

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?

States an explicit condition for use: "Úsala antes de dar una presentación por terminada." It implies this is a pre-flight audit rather than a per-slide inspection tool, but it does not name a specific alternative for single-slide checks.

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 provided, the description carries the full behavioral burden. It does disclose one useful trait — that values are stored as text, preserving signs and hyphens — but says nothing about whether this is a write/mutating operation, permission or document-state requirements, what happens if coordinates or size are omitted, or how the table interacts with existing slide content.

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 dense sentence with no filler, but it front-loads cosmetic styling detail rather than the core action of creating a table. It is compact and readable, though the most decision-relevant information (what the tool actually does) is buried mid-sentence.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description is thin. It omits positioning/sizing behavior, the header toggle, defaults, and any sibling differentiation — an agent would need to read the schema and guess about the rest before calling 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 coverage is a middling 56% (y, alto, ancho, and encabezado are undocumented) and the description never names a single parameter nor adds meaning beyond the prose about alignment and text storage. The alignment sentence gestures at the first-row header concept but never ties it to encabezado=true, leaving the coverage gap uncompensated.

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 (a table with theme styling) and details its formatting (header color, bold title, card-color cells, alignment), but never states the action explicitly — it is only implied that a table is created on a slide. It also gives no hint of how it differs from close siblings like diapositiva_tabla, tabla_estructura, or editar_celdas, so an agent cannot cleanly route between them.

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

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

There is no guidance on when to use this tool, when not to, or which sibling handles the alternative case (e.g. diapositiva_tabla for a slide-level table layout vs. this tool). The reader is left to infer usage entirely from the styling description.

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 still discloses substantive behavior: the style/format is reapplied as a side effect, merging concatenates cell texts with a tab in Keynote, sorting leaves the header on top, and added rows/columns preserve width. It stops short of warning that quitar_fila/quitar_columna destroys cell data or describing what is returned, which are the remaining gaps for a mutation tool carrying the full disclosure burden.

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 core purpose is front-loaded and each parenthetical adds real operational detail rather than filler. It is a single dense sentence with nested clauses, which is slightly harder to scan than a short bulleted breakdown of the seven actions, but nothing is wasted.

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

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

For a 9-parameter mutation tool with no annotations and no output schema, the description covers all seven actions and their key side effects but leaves index semantics, sort direction, quantity handling, and data-loss on removal unstated. Adequate to invoke it, not fully sufficient 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 only 22%, so the description has to compensate, and it partially does: it clarifies `rango` with the "A1:B1" format, that `columna` is the sort key, and that additions go at the end. It says nothing about `descendente` (sort direction), `cantidad`, `tabla` (default 1), or whether `fila`/`columna` are 1-based, leaving several parameters undocumented in both places.

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 specific verb and resource ("Cambia la estructura de una tabla") and then enumerates exactly the seven structural operations that match the `accion` enum, so an agent can tell it apart from content-level siblings like editar_celdas or tabla. It never names an alternative tool explicitly, which keeps it at 4 rather than 5.

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

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

Usage is implied by mapping each action to a situation (fusionar/separar a range, ordenar by a column, agregar al final, quitar), and one real guideline is given (merge empty cells with a filled one because Keynote joins texts with a tab). There is no explicit when-not-to-use guidance or reference to editar_celdas/tabla as alternatives, 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?

No annotations are provided, so the description carries the full behavioral burden. It never states that the tool mutates the presentation, whether it appends to or replaces existing slide content, what happens on a slide with existing objects, or whether the slide must already exist — all critical for a write operation with zero annotation coverage.

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 dense sentence that front-loads the card count and format before detailing header and body. No filler, though the phrase is compressed enough that the creation verb itself is only implicit.

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 7 parameters, no annotations and no output schema, the description should explain positioning behavior and mutation effects; it explains neither. An agent knows what the cards look like but not how placement defaults work or what the call changes on the slide.

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 43%: only documento, diapositiva and x are documented, leaving y, alto and ancho (all optional positioning geometry) undescribed in both schema and description. The description does enrich the tarjetas item semantics (header short, in title typeface/accent color, text below), which goes beyond the bare string schema, but the geometry gap is not compensated.

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 concretely describes the output: a row of 2–4 cards with a short header rendered in the title typeface/accent color and body text below. An agent can picture the artifact it produces. It does not, however, distinguish itself from the near-identical sibling cifras_destacadas (highlighted figures), whose content ('un número, una cifra') it explicitly overlaps 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?

Usage is only implied by the parenthetical content examples ('resúmenes, preguntas, mensajes'), which suggest suitable material. There is no statement of when to prefer this over cifras_destacadas, diapositiva_contenido or agenda, and no prerequisites (e.g., that the presentation must be open).

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 does disclose one important behavior: automatica=true advances the slide on its own after the delay. It does not say whether existing transitions are overwritten, whether this is per-slide mutation, or what permissions/context 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?

Three short sentences, leading with the core concept and then the special-case effect and the auto-advance flag. The condensed phrasing ('Con automatica=true avanza sola tras el retraso') is terse but nothing is wasted.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description covers the headline behavior and one effect's preconditions, but leaves gaps: replacement semantics, per-slide scope, and the meaning of duracion/retraso bounds are not addressed.

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% with retraso/duracion/automatica lacking in-schema descriptions. The description compensates for automatica (auto-advance after retraso) and hints at the magic-move effect, but adds nothing about duracion units/limits or the large efecto enum beyond one value.

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 (the transition from this slide to the next) and the key effect, 'magic move', plus what automatica does. It is clearly distinguishable from siblings like animar_cambio or revelar_por_pasos, though it never states outright that the tool *sets* the transition (it only describes the transition concept).

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 a concrete precondition for the 'magic move' effect (duplicate the slide and move objects with duplicar_diapositiva/mover_objeto), which is genuinely useful routing guidance. However, there is no when-to-use vs. when-not guidance relative to the animation-related siblings, and no note on whether setting a transition replaces an existing one.

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?

readOnlyHint=true already tells the agent this is a safe read, and the description usefully adds that the output is Keynote's own rendering (a fidelity claim an agent could not infer from schema or annotations). It says nothing about cost, latency, whether the document must be open, or how the image is returned, which limits it to a 3.

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

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

One front-loaded sentence with the resource and the fidelity qualifier first, then the purpose. No filler, though the trailing purpose clause overlaps slightly with the image claim it already made.

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 read-only render tool with annotations covering safety and no output schema, the description is nearly sufficient: it names the return format and the fidelity guarantee. The only real omission is the undocumented ancho_max sizing behavior, which matters because it governs the returned image.

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%: documento and diapositiva are well documented in the schema, but ancho_max carries no description anywhere and the description never mentions that output size is controllable. The description adds no parameter meaning beyond the schema, so it sits at the moderate-coverage baseline rather than compensating for the gap.

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

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

States a specific verb and resource ('Devuelve la imagen PNG de una diapositiva') and adds a meaningful qualifier ('tal como la dibuja Keynote'), so the agent knows this is a rendered preview, not a data read. It does not name or contrast with the nearest sibling (exportar), which keeps it from 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?

'para revisar el resultado' implies the use case — visually verifying a slide after edits — but there is no explicit when-to-use/when-not guidance and no mention of when to prefer exportar or revisar_presentacion instead. Usage is inferable but not stated.

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