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

With no annotations, the description carries the burden and does well: it discloses that nothing is executed (implying a safe, non-mutating check), the coverage dimensions (syntax/types/lint, all languages), and per-tool timeout behavior. It does not explicitly state permissions or side-effect safety, which keeps it short of 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?

The core behavior is front-loaded in a single tight sentence; the Args block is docstring-style but each line is informative. Minimal waste, though the Args formatting is slightly verbose for a description field.

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

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

An output schema exists, so return values need not be explained, and the description covers purpose, parameters, and non-execution behavior. The 'detalle de lo ya visto' notion is a bit opaque, but overall it is complete enough for an agent to invoke correctly.

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

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

Schema coverage is 0%, so the description must compensate, and it documents all three params: path accepts an absolute project path or any file within it, timeout is max seconds per tool, and full returns all fields including already-seen detail. This adds real meaning beyond the bare schema titles.

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 (Comprueba) and resource (el proyecto) with concrete scope: syntax, types, and lint across all languages. The phrase 'sin ejecutarlo' implicitly separates it from test/run siblings, 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 contrast with execution ('sin ejecutarlo') implies when to use it versus test, but no alternative tools are named and no when-not guidance is given. Usage must be inferred from the sibling list.

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

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

With no annotations, the description carries the full burden, and it does disclose two important traits: it writes to files and it re-checks after fixing. It still omits permissions needed, reversibility/rollback behavior, whether the re-check can fail the call, and idempotency, so the behavioral picture is only partially filled in.

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 front-loaded and the side effect immediately after, so nothing is padded. But the brevity here reads as under-specification rather than efficiency, since essential calling context is absent.

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

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

An output schema exists, so return values need not be described, yet the definition still omits parameter semantics, prerequisites, and usage routing for a mutation tool that has no annotations to lean on. It is insufficient for an agent to call this confidently versus its siblings.

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

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

Schema description coverage is 0% for both parameters, so the description must compensate. It implies a file target via 'Modifica archivos' but never explains 'path' semantics (file vs directory vs glob) or the 'timeout' parameter at all, leaving the schema's bare titles as the only guidance.

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

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

The description states a specific action ('Aplica las correcciones automáticas SEGURAS y vuelve a comprobar') and discloses the side effect ('Modifica archivos'), so the verb and resource are clear. However, 'fix' is generic and the description never contrasts itself with siblings like check, mutate, or gate, leaving the agent to infer the distinction.

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

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

The word 'SEGURAS' hints that only a safe subset of corrections is applied and implies some other operation handles unsafe ones, but no explicit when-to-use, prerequisite, or alternative tool is named. Nothing tells the agent whether to run check/test/gate before or after this.

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 the meaningful all-or-nothing semantics ('ok solo si TODO pasa'). It stops short of stating whether the tool is read-only or executes project code, what happens on partial failure, or any permission/runtime constraints — only that ok requires everything to pass.

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 summary line followed by a compact argument list — no filler, and the outcome rule is front-loaded before the parameter details. Appropriate size for a three-parameter 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?

Return values are covered by the existing output schema and all parameters are explained, so the definition is largely serviceable. The remaining gap is usage context: nothing says when this gate is preferable to the separate 'check' and 'test' sibling tools, leaving selection ambiguous for an agent with all three available.

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

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

Schema description coverage is 0%, so the description must compensate, and it documents all three parameters: 'path' must be absolute and may point at the project or any file inside it, 'coverage' includes uncovered lines, and 'timeout' is seconds per phase. The 'per phase' detail is genuinely additive beyond the schema's bare number type, though value formats/limits are still unstated.

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 concrete composite action — 'check + test en una llamada' — and its outcome rule ('ok solo si TODO pasa'), which distinguishes it from the standalone 'check' and 'test' siblings. It is clear enough to select, but it never explains what 'check' or 'test' actually verify within this server, so the agent must infer the scope from sibling names.

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

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

'La puerta final' implies this is intended as a terminal validation step, and 'check + test en una llamada' implies it replaces running both separately. However, there is no explicit when-to-use/when-not statement, no mention of prerequisites (e.g. whether tests must be discoverable), and no direct routing against the 'check' and 'test' siblings.

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

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

No annotations, so the description carries the full behavioral burden. It does disclose a real trait — the lesson reappears on its own next to the matching error — but says nothing about persistence, deduplication on repeat calls, or any write-side permissions/effects.

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

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

Front-loads the core action, then the example, then the behavioral note, followed by a tidy Args block. Efficient overall, with only mild redundancy between the main sentence and the Args section.

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

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

An output schema exists, so return values need not be explained, and parameters are well covered. For a simple write tool it is nearly complete; the main gap is no link to the 'recall' sibling that would make the store/retrieve pair obvious.

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?

With 0% schema coverage, the description fully documents all three params: path as an absolute project path, lesson as a one-sentence statement, and about as optional scoping (error code like F821, file, or test name). This adds substantial meaning and format hints the bare schema lacks.

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 ("Guarda una lección del proyecto") and reinforces it with a concrete example ("usar Decimal, nunca float, para dinero"). It does not explicitly differentiate itself from the sibling 'recall', which likely retrieves these lessons, so it falls short of the top band.

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 usage context: record a lesson so you don't repeat an error, and notes it will resurface automatically alongside that error. It never states when NOT to use it nor names 'recall' as the retrieval alternative, so no explicit exclusions.

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

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

With no annotations, the description carries the full burden and does well: it discloses that it operates on COPIES (non-destructive to the original), that each survivor indicates untested behavior, that some mutants are equivalent and require judgment, and that it is currently Python-only. It omits resource/timing expectations and test-framework prerequisites, but the core behavior is well conveyed.

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

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

The key mechanism is front-loaded in the first sentence, and parameters are cleanly structured in an Args block. The survivor/equivalence note is useful but slightly expands the prose; nothing is egregiously wasteful.

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

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

For a complex, multi-step operation this covers the mechanism, all parameters, and the language limitation, and an output schema exists so return values need not be documented. Absent any annotations, it could say more about runtime expectations or required test tooling, but it is largely 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 0%, so the description must compensate and it documents all four parameters. The path/file entries add real meaning (absolute project path vs. optional project-relative single file), while max_mutants and timeout are closer to restatements though timeout adds 'en total' (overall budget).

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 technique (mutation testing: injecting small bugs into COPIES of the code and checking whether tests catch them) with a concrete resource (the project/code under test). It is clearly distinguishable from siblings like 'test' (runs tests) or 'fix' (repairs code). An agent knows exactly what this does.

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

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

The opening question '¿Los tests son buenos?' establishes the use case — assessing test quality — and 'Hoy solo para Python' is an explicit scope limitation. However, it never routes the agent among siblings (e.g., when to reach for mutate vs test) nor states when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It makes the read-only nature reasonably clear by describing an outline listing and advising a subsequent range read, and it explains the folder-wide scope. It says nothing about limits or cost when pointing at a large directory, permissions, or failure modes on invalid paths.

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?

Very short and front-loaded: purpose first, then the range-read advice, then the argument note. The Args block is near-redundant with the schema and the sample output string adds a little noise, but the size is appropriate for a single-parameter 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 an output schema present, the description needn't explain return structure, yet it still conveys the line-range format usefully. For a 1-parameter tool it is broadly complete, but the folder case (recursion depth, file-type filtering) and behavior on large trees are unaddressed, and the description is written in Spanish while the surrounding tool metadata is English.

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

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

Schema coverage is 0% — the schema only says a required string named 'path'. The description meaningfully adds that it must be an absolute path and may refer to either a file or a folder, which the schema does not convey. It leaves ambiguity around relative paths, symlinks, or glob patterns unresolved.

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 concrete output: the functions and classes of a file, or of every file in a folder, including their line ranges. That is a specific resource and scope rather than a restatement of the name. It does not, however, distinguish itself from the sibling 'overview', which an agent could easily confuse it with.

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

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

It gives a follow-up workflow hint ('Lee después solo ese rango, no el archivo entero'), which implies the intended use — cheap navigation before a targeted read. It offers no explicit when-to-use versus 'overview', 'learn' or 'check', nor any exclusion criteria, so guidance remains 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 the full burden and does reasonably well: it discloses the exact data harvested (languages, folders, build/check commands, entry points, doc index, git status), notes the doc index is limited to titles with line numbers, and frames the value as one call instead of many. It never explicitly states the operation is read-only or harmless, which is the main missing behavioral fact for a zero-annotation tool.

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

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

The schema is front-loaded in the first sentence, the usage rule comes second, and parameter notes last. Every clause enumerates a distinct piece of returned content, so nothing is filler despite the density.

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

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

An output schema exists, so return-value documentation is not required, and the description nonetheless orients the agent on scope, usage and the single parameter. For a one-parameter read/aggregate tool this is close to complete; only the absence of any safety/permission statement and any sibling disambiguation keeps it from a 5.

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

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

Schema coverage is 0%, so the description must compensate, and it does: 'ruta absoluta al proyecto o a cualquier archivo dentro de él' specifies that the path must be absolute and that any file inside the project resolves correctly, which is real semantic value the bare string schema does not convey. It stops short of giving path format examples or error behavior.

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

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

The description opens with a specific verb+resource ('Mapa del proyecto en una llamada') and then enumerates exactly what the map contains: lenguajes, carpetas, cómo se comprueba, puntos de entrada, índice de documentación y estado de git. An agent knows precisely what it gets back. It does not differentiate itself from siblings such as 'outline' or 'recall', which may overlap with the documentation-index portion, so it falls short of a 5.

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

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

'Úsalo al empezar en vez de leer README o listar carpetas' gives an explicit trigger (at project start) and an explicit alternative it replaces (manual README reading / folder listing). That is concrete when-to-use guidance, though it names no sibling-tool alternative and gives no when-not-to-use condition.

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 disclosure burden. It usefully reveals that the memory 'se llena sola con cada check/test' (auto-populated) and is ordered by importance, which is real behavioral context. It omits permission/scope behavior and whether results are exhaustive or truncated, though the output schema covers the return shape.

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

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

Front-loaded summary of purpose followed by a use instruction and a clean Args block. The enumeration of memory categories is slightly long but each item disambiguates the return content, so it earns its place.

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

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

An output schema exists, so return values needn't be explained, and the description instead covers purpose, data sources, ordering logic, when to use, and both parameters. Given no annotations, it could say more about safety/read-only nature, but the essentials for correct invocation are present.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: 'path' is defined as an absolute project path, and 'topic' as an optional filter by file, error code, or free text, with a concrete example ('cli.py'). This adds meaning well beyond the bare schema titles, though it could mention path formats or filter precedence.

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 resource (project memory) and enumerates exactly what it returns, ordered by importance: recurring errors, open errors, patterns, recently resolved items, saved lessons. The verb is implicit in the name 'recall' but the content is concrete. It does not explicitly differentiate itself from sibling 'overview', which may overlap in reporting project state.

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?

'Úsalo antes de cambiar código en un proyecto en el que ya trabajaste' gives clear when-to-use context. However, it offers no exclusions and does not name an alternative sibling (e.g., overview or outline) for adjacent needs, so the routing guidance is clear but incomplete.

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

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

With no annotations, the description carries the full behavioral burden and falls short: it never says whether running tests is read-only or can modify the workspace/environment, that execution may be long-running (implied only by the 300s default timeout), or what happens on timeout. It does disclose the cross-language scope and the Python-only nature of coverage, which is some added context.

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

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

The purpose is front-loaded in one sentence, followed by a compact Args block with no filler. The parameter restatement mirrors the schema, but at 0% schema coverage that repetition is functional rather than wasteful.

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

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

An output schema exists, so return values need not be explained, and all five parameters are documented. What is missing is the routing information an agent needs to pick this over siblings and any warning about execution side effects or duration, leaving the definition adequate but incomplete for an execution-style 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 description coverage is 0%, so the description must compensate, and it does: all five parameters are explained, including the important detail that 'path' accepts an absolute path to the project or any file inside it, that 'selector' narrows to one file/test, and that 'coverage' is Python-specific. 'full' is described somewhat cryptically ('el detalle de lo ya visto') but still adds meaning 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 opening sentence states a specific verb and resource ('Ejecuta los tests de todos los lenguajes del proyecto') plus the outcome ('localiza cada fallo'), which is far more informative than the bare name 'test'. It does not, however, distinguish itself from plausible siblings like 'check', 'gate', or 'fix'.

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 the sibling tools (check, gate, fix), no prerequisites, and no exclusions. The only usage signal is implicit in the parameter docs (selector limits scope), which the agent must infer.

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